{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "\n",
    "from torch import nn\n",
    "\n",
    "\n",
    "class PolicyNetAtt(nn.Module):\n",
    "\n",
    "    def __init__(self,\n",
    "                 input_dim: int,\n",
    "                 policy_dim: int = 2):\n",
    "\n",
    "        super(PolicyNetAtt, self).__init__()\n",
    "\n",
    "        self.num_landmark = int((input_dim - 5) / 4)\n",
    "\n",
    "        self.agent_pos_fc1_pi = nn.Linear(5, 32)\n",
    "        self.agent_pos_fc2_pi = nn.Linear(32, 32)\n",
    "        self.landmark_fc1_pi = nn.Linear(3, 64)\n",
    "        self.landmark_fc2_pi = nn.Linear(64, 32)\n",
    "        self.info_fc1_pi = nn.Linear(64, 64)\n",
    "        self.action_fc1_pi = nn.Linear(64, 64)\n",
    "        self.action_fc2_pi = nn.Linear(64, policy_dim)\n",
    "\n",
    "        self.relu = nn.ReLU()\n",
    "        self.tanh = nn.Tanh()\n",
    "        self.softmax = nn.Softmax(dim=2)\n",
    "        \n",
    "    def forward(self, observation: torch.Tensor) -> torch.Tensor:\n",
    "        if len(observation.size()) == 1:\n",
    "            observation = observation[None, :]\n",
    "\n",
    "        # compute the policy\n",
    "        # embeddings of agent's position  \n",
    "        agent_pos_embedding = self.relu(self.agent_pos_fc1_pi(observation[:, :5]))\n",
    "        agent_pos_embedding = self.relu(self.agent_pos_fc2_pi(agent_pos_embedding))\n",
    "\n",
    "        # embeddings of landmarkss\n",
    "        estimated_landmark_pos = observation[:, 5: 5 + 3 * self.num_landmark]\n",
    "        \n",
    "        #landmark_info = torch.cat((estimated_landmark_pos.reshape(observation.size()[0], self.num_landmark, 2),\n",
    "        #                        info_vector.reshape(observation.size()[0], self.num_landmark, 2)), 2)\n",
    "        \n",
    "        landmark_reshape=estimated_landmark_pos.reshape(observation.size()[0], self.num_landmark, 3)\n",
    "        #landmark_embedding = self.relu(self.landmark_fc1_pi(landmark_info))\n",
    "        \n",
    "        landmark_embedding = self.relu(self.landmark_fc1_pi(landmark_reshape))\n",
    "        landmark_embedding = self.relu(self.landmark_fc2_pi(landmark_embedding))\n",
    "\n",
    "        # attention\n",
    "        landmark_embedding_tr = torch.transpose(landmark_embedding, 1, 2)\n",
    "\n",
    "        # mask\n",
    "        mask = observation[:, - self.num_landmark:].unsqueeze(1)\n",
    "        attention = torch.matmul(agent_pos_embedding.unsqueeze(1), landmark_embedding_tr) / 4\n",
    "        attention = attention.masked_fill(mask == 0, -1e10)\n",
    "\n",
    "        att = self.softmax(attention)\n",
    "        landmark_embedding_att = self.relu((torch.matmul(att, torch.transpose(landmark_embedding_tr, 1, 2)).squeeze(1)))\n",
    "\n",
    "        info_embedding = self.relu(self.info_fc1_pi(torch.cat((agent_pos_embedding, landmark_embedding_att), 1)))\n",
    "        action = self.tanh(self.action_fc1_pi(info_embedding))\n",
    "        action = self.tanh(self.action_fc2_pi(action))\n",
    "\n",
    "        if action.size()[0] == 1:\n",
    "            action = action.flatten()\n",
    "\n",
    "        #scaled_action = torch.hstack(((1 + action[0]) * 2.0, action[1] * torch.pi/3))\n",
    "        scaled_action=action\n",
    "\n",
    "        return scaled_action"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(85.7914)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "def zy_rotation_matrix(angle_z, angle_y):\n",
    "    \"\"\"\n",
    "    Function to transform ZY rotations to a 3D rotation matrix in PyTorch.\n",
    "\n",
    "    Args:\n",
    "    - angle_z: Rotation angle around the z-axis (in radians)\n",
    "    - angle_y: Rotation angle around the y-axis (in radians)\n",
    "\n",
    "    Returns:\n",
    "    - rotation_matrix: 3D rotation matrix representing the ZY rotations\n",
    "    \"\"\"\n",
    "    cos_z = torch.cos(angle_z)\n",
    "    sin_z = torch.sin(angle_z)\n",
    "    cos_y = torch.cos(angle_y)\n",
    "    sin_y = torch.sin(angle_y)\n",
    "\n",
    "    rot_z = torch.tensor([[cos_z, -sin_z, 0],\n",
    "                          [sin_z, cos_z, 0],\n",
    "                          [0, 0, 1]])\n",
    "\n",
    "    rot_y = torch.tensor([[cos_y, 0, sin_y],\n",
    "                          [0, 1, 0],\n",
    "                          [-sin_y, 0, cos_y]])\n",
    "\n",
    "    rotation_matrix = torch.mm(rot_z, rot_y)\n",
    "\n",
    "    return rotation_matrix\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "def calculate_pc_reward(pc_C):\n",
    "    \n",
    "    pc=pc_C\n",
    "    pc_range=torch.sqrt(torch.sum(pc**2,axis=0))\n",
    "    pc_x=pc[0,:]\n",
    "    pc_bear=torch.acos(pc_x/pc_range)\n",
    "    cb=pc_x/pc_range #cos(bear)\n",
    "    \n",
    "    k2=0.11\n",
    "    k1=0.50\n",
    "    k0=0.39\n",
    "    \n",
    "    r=k2*cb**2+k1*cb+k0\n",
    "    \n",
    "    v=1/(1+torch.exp(-4*cb))\n",
    "    \n",
    "    \n",
    "    reward=torch.sum(r)\n",
    "    \n",
    "    return reward\n",
    "    \n",
    "    \n",
    "pc_C=torch.rand([3,128])\n",
    "calculate_pc_reward(pc_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([-0.1154,  0.0108], grad_fn=<ReshapeAliasBackward0>)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from torch.optim import SGD, Adam\n",
    "class Agent:\n",
    "    \n",
    "    def __init__(self,yaw=0,pitch=0,vx=0,vy=0,vz=0,max_pc_size=1,fov=np.pi/2,lr=1e-4):\n",
    "        \n",
    "        self.state=torch.Tensor([yaw,pitch,vx,vy,vz])\n",
    "        self.max_pc_size=max_pc_size\n",
    "        self.fov=fov\n",
    "        self.R_W_C=self.calculate_rotation_matrix(self.state)\n",
    "        \n",
    "        self._policy=PolicyNetAtt(input_dim=max_pc_size*4+5)\n",
    "        self._policy_optimizer=Adam(self._policy.parameters(), lr=lr)\n",
    "        self.loss=0.\n",
    "        \n",
    "    def reset_state(self):\n",
    "        yaw=0\n",
    "        pitch=torch.FloatTensor(1).uniform_(-np.pi/4,np.pi/4)\n",
    "        vx=torch.FloatTensor(1).uniform_(-20,20)*1\n",
    "        vy=torch.FloatTensor(1).uniform_(-20,20)*1\n",
    "        vz=torch.FloatTensor(1).uniform_(-2,2)*1\n",
    "        \n",
    "        self.state=torch.Tensor([yaw,pitch,vx,vy,vz])\n",
    "        self.R_W_C=self.calculate_rotation_matrix(self.state)\n",
    "        self.loss=0.\n",
    "    \n",
    "    def calculate_rotation_matrix(self,state):\n",
    "        R_W_C=zy_rotation_matrix(angle_z=state[0],angle_y=state[1])\n",
    "        return R_W_C\n",
    "    \n",
    "    def reset_pointcloud(self):\n",
    "        self.pc_size=int(np.random.uniform(1,self.max_pc_size))\n",
    "        self.pc_size=self.max_pc_size\n",
    "        \n",
    "        #generate random pointcloud in camera view\n",
    "        phi_pc_C=torch.FloatTensor(self.pc_size,1).uniform_(-self.fov,self.fov)\n",
    "        psi_pc_C=torch.FloatTensor(self.pc_size,1).uniform_(-self.fov,self.fov)\n",
    "        range_pc_C=torch.FloatTensor(self.pc_size,1).uniform_(1,3)\n",
    "        \n",
    "        x_pc_C=range_pc_C*torch.cos(phi_pc_C)*torch.cos(psi_pc_C)\n",
    "        y_pc_C=range_pc_C*torch.sin(phi_pc_C)*torch.cos(psi_pc_C)\n",
    "        z_pc_C=range_pc_C*torch.sin(psi_pc_C)\n",
    "        \n",
    "        self.pc_C=torch.hstack([x_pc_C,y_pc_C,z_pc_C]).T\n",
    "        self.pc_W=self.R_W_C.T @ self.pc_C\n",
    "        \n",
    "    \n",
    "    def update_pointcloud(self):\n",
    "        dt=0.1\n",
    "        vW=self.state[2:].reshape([3,1])*0\n",
    "        \n",
    "        self.pc_W=self.pc_W-vW*dt\n",
    "        self.pc_C=self.R_W_C @ self.pc_W\n",
    "        self.loss+=(1-calculate_pc_reward(self.pc_C)/self.pc_size)\n",
    "        \n",
    "    \n",
    "    \n",
    "    def update_state(self,action):\n",
    "        dt=0.1\n",
    "        self.state[:2]+=action*dt\n",
    "        self.R_W_C=self.calculate_rotation_matrix(self.state)\n",
    "        \n",
    "    \n",
    "\n",
    "\n",
    "    def plan(self,pc_W,state):\n",
    "        \n",
    "        padding=torch.zeros(3*(self.max_pc_size-self.pc_size))\n",
    "        mask=torch.tensor([True]*self.pc_size+[False]*(self.max_pc_size-self.pc_size))\n",
    "        \n",
    "        net_input=torch.hstack((state,pc_W.flatten(),padding,mask))\n",
    "        action=self._policy.forward(net_input)\n",
    "        \n",
    "        \n",
    "        \n",
    "        return action\n",
    "    \n",
    "    def update_policy_grad(self, train=True,verbose=False):\n",
    "        \n",
    "        pc_C=self.R_W_C @ self.pc_W\n",
    "        \n",
    "        reward=(1-calculate_pc_reward(pc_C)/self.pc_size)\n",
    "        if train==True:\n",
    "            #reward.backward()\n",
    "            self.loss.backward()\n",
    "            reward=self.loss\n",
    "            self.loss=0\n",
    "            \n",
    "        \n",
    "        if verbose:\n",
    "            print(calculate_pc_reward(pc_C)/self.pc_size)\n",
    "        \n",
    "        return reward\n",
    "        \n",
    "\n",
    "    def eval_policy(self):\n",
    "        self._policy.eval()\n",
    "\n",
    "    def train_policy(self):\n",
    "        self._policy.train()\n",
    "        \n",
    "    def set_policy_grad_to_zero(self):\n",
    "        self._policy_optimizer.zero_grad()\n",
    "        \n",
    "    def policy_step(self, debug=False):\n",
    "        if debug:\n",
    "            param_list = []\n",
    "            for i, p in enumerate(self._policy.parameters()):\n",
    "                param_list.append(p.data.detach().clone())\n",
    "\n",
    "        self._policy_optimizer.step()\n",
    "\n",
    "        if debug:\n",
    "            total_param_rssd = 0\n",
    "            grad_power = 0\n",
    "            for i, p in enumerate(self._policy.parameters()):\n",
    "                if p.grad is not None:\n",
    "                    grad_power += (p.grad ** 2).sum()\n",
    "                else:\n",
    "                    grad_power += 0\n",
    "                total_param_rssd += ((param_list[i] - p.data) ** 2).sum().sqrt()\n",
    "\n",
    "            print(\"Gradient power after backward: {}\".format(grad_power))\n",
    "            print(\"RSSD of weights after applying the gradient: {}\".format(total_param_rssd))\n",
    "\n",
    "        \n",
    "    def get_policy_state_dict(self):\n",
    "        return self._policy.state_dict()\n",
    "\n",
    "    def load_policy_state_dict(self, load_model):\n",
    "        self._policy.load_state_dict(torch.load(load_model))\n",
    "        \n",
    "\n",
    "a=Agent()\n",
    "\n",
    "\n",
    "a.reset_state()\n",
    "a.reset_pointcloud()\n",
    "\n",
    "\n",
    "\n",
    "action=a.plan(a.pc_W,a.state)\n",
    "#action=torch.Tensor([0,0])\n",
    "a.update_state(action=action)\n",
    "a.update_pointcloud()\n",
    "\n",
    "\n",
    "r=calculate_pc_reward(a.pc_C)/a.pc_size\n",
    "action"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(0.8271, grad_fn=<DivBackward0>)\n",
      "tensor(0.8226, grad_fn=<DivBackward0>)\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "print(calculate_pc_reward(a.pc_C)/a.pc_size)\n",
    "action=a.plan(a.pc_W,a.state)\n",
    "a.update_state(action=action)\n",
    "a.update_pointcloud()\n",
    "print(calculate_pc_reward(a.pc_C)/a.pc_size)\n",
    "\n",
    "r=calculate_pc_reward(a.pc_C)/a.pc_size\n",
    "r.backward()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 finished!\n",
      "Normalized average reward at epoch 0: 0.4253278377155463\n",
      "Normalized median reward at epoch 0: 0.44679202139377594\n",
      "Epoch 2 finished!\n",
      "Normalized average reward at epoch 1: 0.39314009100198744\n",
      "Normalized median reward at epoch 1: 0.3620755970478058\n",
      "Epoch 3 finished!\n",
      "Normalized average reward at epoch 2: 0.41815757329265274\n",
      "Normalized median reward at epoch 2: 0.39936429262161255\n",
      "Epoch 4 finished!\n",
      "Normalized average reward at epoch 3: 0.4180157051732143\n",
      "Normalized median reward at epoch 3: 0.42892369627952576\n",
      "Epoch 5 finished!\n",
      "Normalized average reward at epoch 4: 0.43452030842502914\n",
      "Normalized median reward at epoch 4: 0.4348653554916382\n",
      "Epoch 6 finished!\n",
      "Normalized average reward at epoch 5: 0.4815913756688436\n",
      "Normalized median reward at epoch 5: 0.4740409851074219\n",
      "Epoch 7 finished!\n",
      "Normalized average reward at epoch 6: 0.41240919729073844\n",
      "Normalized median reward at epoch 6: 0.4067677706480026\n",
      "Epoch 8 finished!\n",
      "Normalized average reward at epoch 7: 0.4369913145278891\n",
      "Normalized median reward at epoch 7: 0.44084687530994415\n",
      "Epoch 9 finished!\n",
      "Normalized average reward at epoch 8: 0.44082112175722915\n",
      "Normalized median reward at epoch 8: 0.42592328786849976\n",
      "Epoch 10 finished!\n",
      "Normalized average reward at epoch 9: 0.42679985364278156\n",
      "Normalized median reward at epoch 9: 0.3769599348306656\n",
      "Epoch 11 finished!\n",
      "Normalized average reward at epoch 10: 0.4448735326528549\n",
      "Normalized median reward at epoch 10: 0.40010587871074677\n",
      "Epoch 12 finished!\n",
      "Normalized average reward at epoch 11: 0.49452496158579984\n",
      "Normalized median reward at epoch 11: 0.5001601427793503\n",
      "Epoch 13 finished!\n",
      "Normalized average reward at epoch 12: 0.34794736877083776\n",
      "Normalized median reward at epoch 12: 0.31924885511398315\n",
      "Epoch 14 finished!\n",
      "Normalized average reward at epoch 13: 0.4306314198921124\n",
      "Normalized median reward at epoch 13: 0.4397249072790146\n",
      "Epoch 15 finished!\n",
      "Normalized average reward at epoch 14: 0.42367859482765197\n",
      "Normalized median reward at epoch 14: 0.4302367717027664\n",
      "Epoch 16 finished!\n",
      "Normalized average reward at epoch 15: 0.4394034723440806\n",
      "Normalized median reward at epoch 15: 0.3808279037475586\n",
      "Epoch 17 finished!\n",
      "Normalized average reward at epoch 16: 0.42068918322523435\n",
      "Normalized median reward at epoch 16: 0.397198885679245\n",
      "Epoch 18 finished!\n",
      "Normalized average reward at epoch 17: 0.3345676171282927\n",
      "Normalized median reward at epoch 17: 0.30875954031944275\n",
      "Epoch 19 finished!\n",
      "Normalized average reward at epoch 18: 0.37985009339948494\n",
      "Normalized median reward at epoch 18: 0.32468095421791077\n",
      "Epoch 20 finished!\n",
      "Normalized average reward at epoch 19: 0.44279524448017277\n",
      "Normalized median reward at epoch 19: 0.4327150732278824\n",
      "Epoch 21 finished!\n",
      "Normalized average reward at epoch 20: 0.3877114416410526\n",
      "Normalized median reward at epoch 20: 0.3023713380098343\n",
      "Epoch 22 finished!\n",
      "Normalized average reward at epoch 21: 0.493420897424221\n",
      "Normalized median reward at epoch 21: 0.5200694799423218\n",
      "Epoch 23 finished!\n",
      "Normalized average reward at epoch 22: 0.47504542022943497\n",
      "Normalized median reward at epoch 22: 0.4945201426744461\n",
      "Epoch 24 finished!\n",
      "Normalized average reward at epoch 23: 0.45451052362720173\n",
      "Normalized median reward at epoch 23: 0.5070227384567261\n",
      "Epoch 25 finished!\n",
      "Normalized average reward at epoch 24: 0.4947453965743383\n",
      "Normalized median reward at epoch 24: 0.526362419128418\n",
      "Epoch 26 finished!\n",
      "Normalized average reward at epoch 25: 0.4681990089515845\n",
      "Normalized median reward at epoch 25: 0.5063829571008682\n",
      "Epoch 27 finished!\n",
      "Normalized average reward at epoch 26: 0.3980154937133193\n",
      "Normalized median reward at epoch 26: 0.39027316868305206\n",
      "Epoch 28 finished!\n",
      "Normalized average reward at epoch 27: 0.34892626032233237\n",
      "Normalized median reward at epoch 27: 0.3122360110282898\n",
      "Epoch 29 finished!\n",
      "Normalized average reward at epoch 28: 0.43006703729430834\n",
      "Normalized median reward at epoch 28: 0.446929007768631\n",
      "Epoch 30 finished!\n",
      "Normalized average reward at epoch 29: 0.47929172242681184\n",
      "Normalized median reward at epoch 29: 0.4541051536798477\n",
      "Epoch 31 finished!\n",
      "Normalized average reward at epoch 30: 0.41033027581870557\n",
      "Normalized median reward at epoch 30: 0.3875289410352707\n",
      "Epoch 32 finished!\n",
      "Normalized average reward at epoch 31: 0.4750319182872772\n",
      "Normalized median reward at epoch 31: 0.46243536472320557\n",
      "Epoch 33 finished!\n",
      "Normalized average reward at epoch 32: 0.4749760051568349\n",
      "Normalized median reward at epoch 32: 0.4034658372402191\n",
      "Epoch 34 finished!\n",
      "Normalized average reward at epoch 33: 0.5316837890694539\n",
      "Normalized median reward at epoch 33: 0.5528780817985535\n",
      "Epoch 35 finished!\n",
      "Normalized average reward at epoch 34: 0.4982230233649413\n",
      "Normalized median reward at epoch 34: 0.5300498306751251\n",
      "Epoch 36 finished!\n",
      "Normalized average reward at epoch 35: 0.3814471609890461\n",
      "Normalized median reward at epoch 35: 0.4000224173069\n",
      "Epoch 37 finished!\n",
      "Normalized average reward at epoch 36: 0.5159800445040067\n",
      "Normalized median reward at epoch 36: 0.5216217041015625\n",
      "Epoch 38 finished!\n",
      "Normalized average reward at epoch 37: 0.35835844799876215\n",
      "Normalized median reward at epoch 37: 0.33825917541980743\n",
      "Epoch 39 finished!\n",
      "Normalized average reward at epoch 38: 0.5109384303291639\n",
      "Normalized median reward at epoch 38: 0.5062255859375\n",
      "Epoch 40 finished!\n",
      "Normalized average reward at epoch 39: 0.3556164431075255\n",
      "Normalized median reward at epoch 39: 0.31264543533325195\n",
      "Epoch 41 finished!\n",
      "Normalized average reward at epoch 40: 0.38720284923911097\n",
      "Normalized median reward at epoch 40: 0.3856556713581085\n",
      "Epoch 42 finished!\n",
      "Normalized average reward at epoch 41: 0.4662728451192379\n",
      "Normalized median reward at epoch 41: 0.44696398079395294\n",
      "Epoch 43 finished!\n",
      "Normalized average reward at epoch 42: 0.4308876499533653\n",
      "Normalized median reward at epoch 42: 0.41933736205101013\n",
      "Epoch 44 finished!\n",
      "Normalized average reward at epoch 43: 0.4490525354941686\n",
      "Normalized median reward at epoch 43: 0.49628299474716187\n",
      "Epoch 45 finished!\n",
      "Normalized average reward at epoch 44: 0.3831737445667386\n",
      "Normalized median reward at epoch 44: 0.3384159654378891\n",
      "Epoch 46 finished!\n",
      "Normalized average reward at epoch 45: 0.46618099361658094\n",
      "Normalized median reward at epoch 45: 0.5365577936172485\n",
      "Epoch 47 finished!\n",
      "Normalized average reward at epoch 46: 0.47187369714180627\n",
      "Normalized median reward at epoch 46: 0.4200429618358612\n",
      "Epoch 48 finished!\n",
      "Normalized average reward at epoch 47: 0.4673302558561166\n",
      "Normalized median reward at epoch 47: 0.5149574875831604\n",
      "Epoch 49 finished!\n",
      "Normalized average reward at epoch 48: 0.42700891563047966\n",
      "Normalized median reward at epoch 48: 0.40346160531044006\n",
      "Epoch 50 finished!\n",
      "Normalized average reward at epoch 49: 0.42408371791243554\n",
      "Normalized median reward at epoch 49: 0.3985631763935089\n",
      "Epoch 51 finished!\n",
      "Normalized average reward at epoch 50: 0.36678019699951014\n",
      "Normalized median reward at epoch 50: 0.40368419885635376\n",
      "Epoch 52 finished!\n",
      "Normalized average reward at epoch 51: 0.4502284649759531\n",
      "Normalized median reward at epoch 51: 0.4591910243034363\n",
      "Epoch 53 finished!\n",
      "Normalized average reward at epoch 52: 0.4263624252130588\n",
      "Normalized median reward at epoch 52: 0.45423270761966705\n",
      "Epoch 54 finished!\n",
      "Normalized average reward at epoch 53: 0.482458238179485\n",
      "Normalized median reward at epoch 53: 0.4731070548295975\n",
      "Epoch 55 finished!\n",
      "Normalized average reward at epoch 54: 0.4355332483847936\n",
      "Normalized median reward at epoch 54: 0.4347657412290573\n",
      "Epoch 56 finished!\n",
      "Normalized average reward at epoch 55: 0.36578427950541176\n",
      "Normalized median reward at epoch 55: 0.3002048134803772\n",
      "Epoch 57 finished!\n",
      "Normalized average reward at epoch 56: 0.4540200296168526\n",
      "Normalized median reward at epoch 56: 0.4289921075105667\n",
      "Epoch 58 finished!\n",
      "Normalized average reward at epoch 57: 0.42441434860229493\n",
      "Normalized median reward at epoch 57: 0.42732444405555725\n",
      "Epoch 59 finished!\n",
      "Normalized average reward at epoch 58: 0.3851200086375078\n",
      "Normalized median reward at epoch 58: 0.3249882161617279\n",
      "Epoch 60 finished!\n",
      "Normalized average reward at epoch 59: 0.49732687696814537\n",
      "Normalized median reward at epoch 59: 0.48871375620365143\n",
      "Epoch 61 finished!\n",
      "Normalized average reward at epoch 60: 0.4590739111105601\n",
      "Normalized median reward at epoch 60: 0.5210034400224686\n",
      "Epoch 62 finished!\n",
      "Normalized average reward at epoch 61: 0.43979147747159003\n",
      "Normalized median reward at epoch 61: 0.4667547792196274\n",
      "Epoch 63 finished!\n",
      "Normalized average reward at epoch 62: 0.4552299658457438\n",
      "Normalized median reward at epoch 62: 0.4188595563173294\n",
      "Epoch 64 finished!\n",
      "Normalized average reward at epoch 63: 0.44169986868898076\n",
      "Normalized median reward at epoch 63: 0.45229262113571167\n",
      "Epoch 65 finished!\n",
      "Normalized average reward at epoch 64: 0.43955435007810595\n",
      "Normalized median reward at epoch 64: 0.4155762642621994\n",
      "Epoch 66 finished!\n",
      "Normalized average reward at epoch 65: 0.4692975441614787\n",
      "Normalized median reward at epoch 65: 0.4956556409597397\n",
      "Epoch 67 finished!\n",
      "Normalized average reward at epoch 66: 0.3808295547962189\n",
      "Normalized median reward at epoch 66: 0.3543342798948288\n",
      "Epoch 68 finished!\n",
      "Normalized average reward at epoch 67: 0.45508245304226874\n",
      "Normalized median reward at epoch 67: 0.4524548649787903\n",
      "Epoch 69 finished!\n",
      "Normalized average reward at epoch 68: 0.40988833755254744\n",
      "Normalized median reward at epoch 68: 0.4260729104280472\n",
      "Epoch 70 finished!\n",
      "Normalized average reward at epoch 69: 0.3945846865574519\n",
      "Normalized median reward at epoch 69: 0.36583688855171204\n",
      "Epoch 71 finished!\n",
      "Normalized average reward at epoch 70: 0.5007030400137107\n",
      "Normalized median reward at epoch 70: 0.5215726494789124\n",
      "Epoch 72 finished!\n",
      "Normalized average reward at epoch 71: 0.44150630831718446\n",
      "Normalized median reward at epoch 71: 0.42349687218666077\n",
      "Epoch 73 finished!\n",
      "Normalized average reward at epoch 72: 0.40859711468219756\n",
      "Normalized median reward at epoch 72: 0.385394424200058\n",
      "Epoch 74 finished!\n",
      "Normalized average reward at epoch 73: 0.5034136295318603\n",
      "Normalized median reward at epoch 73: 0.5490832626819611\n",
      "Epoch 75 finished!\n",
      "Normalized average reward at epoch 74: 0.4660219783584277\n",
      "Normalized median reward at epoch 74: 0.4534205198287964\n",
      "Epoch 76 finished!\n",
      "Normalized average reward at epoch 75: 0.46241847754766546\n",
      "Normalized median reward at epoch 75: 0.5292984545230865\n",
      "Epoch 77 finished!\n",
      "Normalized average reward at epoch 76: 0.48331539581219357\n",
      "Normalized median reward at epoch 76: 0.4347785711288452\n",
      "Epoch 78 finished!\n",
      "Normalized average reward at epoch 77: 0.42578081289927167\n",
      "Normalized median reward at epoch 77: 0.3883504569530487\n",
      "Epoch 79 finished!\n",
      "Normalized average reward at epoch 78: 0.39709936156868936\n",
      "Normalized median reward at epoch 78: 0.4252231568098068\n",
      "Epoch 80 finished!\n",
      "Normalized average reward at epoch 79: 0.42467642997701965\n",
      "Normalized median reward at epoch 79: 0.37206172943115234\n",
      "Epoch 81 finished!\n",
      "Normalized average reward at epoch 80: 0.40234897583723067\n",
      "Normalized median reward at epoch 80: 0.3665506988763809\n",
      "Epoch 82 finished!\n",
      "Normalized average reward at epoch 81: 0.41262537402411303\n",
      "Normalized median reward at epoch 81: 0.4059182405471802\n",
      "Epoch 83 finished!\n",
      "Normalized average reward at epoch 82: 0.43123030960559844\n",
      "Normalized median reward at epoch 82: 0.42523056268692017\n",
      "Epoch 84 finished!\n",
      "Normalized average reward at epoch 83: 0.4213466120262941\n",
      "Normalized median reward at epoch 83: 0.44358401000499725\n",
      "Epoch 85 finished!\n",
      "Normalized average reward at epoch 84: 0.40928975244363147\n",
      "Normalized median reward at epoch 84: 0.4029727429151535\n",
      "Epoch 86 finished!\n",
      "Normalized average reward at epoch 85: 0.46067098577817284\n",
      "Normalized median reward at epoch 85: 0.4534359276294708\n",
      "Epoch 87 finished!\n",
      "Normalized average reward at epoch 86: 0.4355562391380469\n",
      "Normalized median reward at epoch 86: 0.43377313017845154\n",
      "Epoch 88 finished!\n",
      "Normalized average reward at epoch 87: 0.48716076562801996\n",
      "Normalized median reward at epoch 87: 0.5199236869812012\n",
      "Epoch 89 finished!\n",
      "Normalized average reward at epoch 88: 0.42880048776666324\n",
      "Normalized median reward at epoch 88: 0.4537275433540344\n",
      "Epoch 90 finished!\n",
      "Normalized average reward at epoch 89: 0.4474938637266556\n",
      "Normalized median reward at epoch 89: 0.4432280659675598\n",
      "Epoch 91 finished!\n",
      "Normalized average reward at epoch 90: 0.40275175323088963\n",
      "Normalized median reward at epoch 90: 0.4387058615684509\n",
      "Epoch 92 finished!\n",
      "Normalized average reward at epoch 91: 0.431165744860967\n",
      "Normalized median reward at epoch 91: 0.4544687867164612\n",
      "Epoch 93 finished!\n",
      "Normalized average reward at epoch 92: 0.42912588715553285\n",
      "Normalized median reward at epoch 92: 0.4042082577943802\n",
      "Epoch 94 finished!\n",
      "Normalized average reward at epoch 93: 0.38118606408437095\n",
      "Normalized median reward at epoch 93: 0.3521602600812912\n",
      "Epoch 95 finished!\n",
      "Normalized average reward at epoch 94: 0.42464217096567153\n",
      "Normalized median reward at epoch 94: 0.4057781398296356\n",
      "Epoch 96 finished!\n",
      "Normalized average reward at epoch 95: 0.4627431077261766\n",
      "Normalized median reward at epoch 95: 0.4797370731830597\n",
      "Epoch 97 finished!\n",
      "Normalized average reward at epoch 96: 0.3506683270136515\n",
      "Normalized median reward at epoch 96: 0.2861897349357605\n",
      "Epoch 98 finished!\n",
      "Normalized average reward at epoch 97: 0.3643577520425121\n",
      "Normalized median reward at epoch 97: 0.351033091545105\n",
      "Epoch 99 finished!\n",
      "Normalized average reward at epoch 98: 0.3988686755299568\n",
      "Normalized median reward at epoch 98: 0.3874078840017319\n",
      "Epoch 100 finished!\n",
      "Normalized average reward at epoch 99: 0.40939090612034\n",
      "Normalized median reward at epoch 99: 0.39163631200790405\n",
      "Epoch 101 finished!\n",
      "Normalized average reward at epoch 100: 0.3595855382581552\n",
      "Normalized median reward at epoch 100: 0.3768332898616791\n",
      "Epoch 102 finished!\n",
      "Normalized average reward at epoch 101: 0.40049220820267994\n",
      "Normalized median reward at epoch 101: 0.36140818893909454\n",
      "Epoch 103 finished!\n",
      "Normalized average reward at epoch 102: 0.4100155853976806\n",
      "Normalized median reward at epoch 102: 0.3829992562532425\n",
      "Epoch 104 finished!\n",
      "Normalized average reward at epoch 103: 0.47375094667077067\n",
      "Normalized median reward at epoch 103: 0.4991754740476608\n",
      "Epoch 105 finished!\n",
      "Normalized average reward at epoch 104: 0.35894286359349886\n",
      "Normalized median reward at epoch 104: 0.33358411490917206\n",
      "Epoch 106 finished!\n",
      "Normalized average reward at epoch 105: 0.47591877803206445\n",
      "Normalized median reward at epoch 105: 0.46838341653347015\n",
      "Epoch 107 finished!\n",
      "Normalized average reward at epoch 106: 0.4688982417186101\n",
      "Normalized median reward at epoch 106: 0.49756474792957306\n",
      "Epoch 108 finished!\n",
      "Normalized average reward at epoch 107: 0.4418676703547438\n",
      "Normalized median reward at epoch 107: 0.48071201145648956\n",
      "Epoch 109 finished!\n",
      "Normalized average reward at epoch 108: 0.39395944302280744\n",
      "Normalized median reward at epoch 108: 0.3553363084793091\n",
      "Epoch 110 finished!\n",
      "Normalized average reward at epoch 109: 0.38270540088415145\n",
      "Normalized median reward at epoch 109: 0.39049431681632996\n",
      "Epoch 111 finished!\n",
      "Normalized average reward at epoch 110: 0.37474095188081263\n",
      "Normalized median reward at epoch 110: 0.35100869834423065\n",
      "Epoch 112 finished!\n",
      "Normalized average reward at epoch 111: 0.4571541105707487\n",
      "Normalized median reward at epoch 111: 0.49500806629657745\n",
      "Epoch 113 finished!\n",
      "Normalized average reward at epoch 112: 0.38330091374615827\n",
      "Normalized median reward at epoch 112: 0.39135192334651947\n",
      "Epoch 114 finished!\n",
      "Normalized average reward at epoch 113: 0.4129382729530334\n",
      "Normalized median reward at epoch 113: 0.4013947993516922\n",
      "Epoch 115 finished!\n",
      "Normalized average reward at epoch 114: 0.43387079909443854\n",
      "Normalized median reward at epoch 114: 0.4321604371070862\n",
      "Epoch 116 finished!\n",
      "Normalized average reward at epoch 115: 0.42219875330726303\n",
      "Normalized median reward at epoch 115: 0.42585107684135437\n",
      "Epoch 117 finished!\n",
      "Normalized average reward at epoch 116: 0.44566078335046766\n",
      "Normalized median reward at epoch 116: 0.4522024691104889\n",
      "Epoch 118 finished!\n",
      "Normalized average reward at epoch 117: 0.3775852280358473\n",
      "Normalized median reward at epoch 117: 0.38079382479190826\n",
      "Epoch 119 finished!\n",
      "Normalized average reward at epoch 118: 0.4625086029370626\n",
      "Normalized median reward at epoch 118: 0.423704594373703\n",
      "Epoch 120 finished!\n",
      "Normalized average reward at epoch 119: 0.41959897155563036\n",
      "Normalized median reward at epoch 119: 0.41365741193294525\n",
      "Epoch 121 finished!\n",
      "Normalized average reward at epoch 120: 0.4493540686244766\n",
      "Normalized median reward at epoch 120: 0.3983469158411026\n",
      "Epoch 122 finished!\n",
      "Normalized average reward at epoch 121: 0.3347731443742911\n",
      "Normalized median reward at epoch 121: 0.3395664244890213\n",
      "Epoch 123 finished!\n",
      "Normalized average reward at epoch 122: 0.3722321879118681\n",
      "Normalized median reward at epoch 122: 0.3429677039384842\n",
      "Epoch 124 finished!\n",
      "Normalized average reward at epoch 123: 0.3949193499982357\n",
      "Normalized median reward at epoch 123: 0.36181914806365967\n",
      "Epoch 125 finished!\n",
      "Normalized average reward at epoch 124: 0.4525511513153712\n",
      "Normalized median reward at epoch 124: 0.4401819407939911\n",
      "Epoch 126 finished!\n",
      "Normalized average reward at epoch 125: 0.4804214258988698\n",
      "Normalized median reward at epoch 125: 0.45038630068302155\n",
      "Epoch 127 finished!\n",
      "Normalized average reward at epoch 126: 0.470876132696867\n",
      "Normalized median reward at epoch 126: 0.4838176369667053\n",
      "Epoch 128 finished!\n",
      "Normalized average reward at epoch 127: 0.40932924039661883\n",
      "Normalized median reward at epoch 127: 0.4634557217359543\n",
      "Epoch 129 finished!\n",
      "Normalized average reward at epoch 128: 0.43624863935013614\n",
      "Normalized median reward at epoch 128: 0.42093604803085327\n",
      "Epoch 130 finished!\n",
      "Normalized average reward at epoch 129: 0.4184177356461684\n",
      "Normalized median reward at epoch 129: 0.37031689286231995\n",
      "Epoch 131 finished!\n",
      "Normalized average reward at epoch 130: 0.44154913096378245\n",
      "Normalized median reward at epoch 130: 0.42608004808425903\n",
      "Epoch 132 finished!\n",
      "Normalized average reward at epoch 131: 0.35623813420534134\n",
      "Normalized median reward at epoch 131: 0.37021583318710327\n",
      "Epoch 133 finished!\n",
      "Normalized average reward at epoch 132: 0.40460989996790886\n",
      "Normalized median reward at epoch 132: 0.3675777167081833\n",
      "Epoch 134 finished!\n",
      "Normalized average reward at epoch 133: 0.5177933876713117\n",
      "Normalized median reward at epoch 133: 0.5162564218044281\n",
      "Epoch 135 finished!\n",
      "Normalized average reward at epoch 134: 0.39483286688725155\n",
      "Normalized median reward at epoch 134: 0.370778352022171\n",
      "Epoch 136 finished!\n",
      "Normalized average reward at epoch 135: 0.3470584327975909\n",
      "Normalized median reward at epoch 135: 0.29380136728286743\n",
      "Epoch 137 finished!\n",
      "Normalized average reward at epoch 136: 0.43794364780187606\n",
      "Normalized median reward at epoch 136: 0.440108984708786\n",
      "Epoch 138 finished!\n",
      "Normalized average reward at epoch 137: 0.44523132195075354\n",
      "Normalized median reward at epoch 137: 0.43513698875904083\n",
      "Epoch 139 finished!\n",
      "Normalized average reward at epoch 138: 0.41298525892198085\n",
      "Normalized median reward at epoch 138: 0.40267692506313324\n",
      "Epoch 140 finished!\n",
      "Normalized average reward at epoch 139: 0.39823567991455394\n",
      "Normalized median reward at epoch 139: 0.3167574852705002\n",
      "Epoch 141 finished!\n",
      "Normalized average reward at epoch 140: 0.4210031288986405\n",
      "Normalized median reward at epoch 140: 0.37631508708000183\n",
      "Epoch 142 finished!\n",
      "Normalized average reward at epoch 141: 0.4036551994582017\n",
      "Normalized median reward at epoch 141: 0.3978077918291092\n",
      "Epoch 143 finished!\n",
      "Normalized average reward at epoch 142: 0.4374080426990986\n",
      "Normalized median reward at epoch 142: 0.43464112281799316\n",
      "Epoch 144 finished!\n",
      "Normalized average reward at epoch 143: 0.4297889320800702\n",
      "Normalized median reward at epoch 143: 0.4164298474788666\n",
      "Epoch 145 finished!\n",
      "Normalized average reward at epoch 144: 0.4407454573859771\n",
      "Normalized median reward at epoch 144: 0.42923663556575775\n",
      "Epoch 146 finished!\n",
      "Normalized average reward at epoch 145: 0.38100589712460836\n",
      "Normalized median reward at epoch 145: 0.3055304288864136\n",
      "Epoch 147 finished!\n",
      "Normalized average reward at epoch 146: 0.4270361617207527\n",
      "Normalized median reward at epoch 146: 0.40172797441482544\n",
      "Epoch 148 finished!\n",
      "Normalized average reward at epoch 147: 0.38924629328151544\n",
      "Normalized median reward at epoch 147: 0.3859720528125763\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[6], line 22\u001b[0m\n\u001b[1;32m     19\u001b[0m         a\u001b[39m.\u001b[39mupdate_state(action\u001b[39m=\u001b[39maction)\n\u001b[1;32m     20\u001b[0m         a\u001b[39m.\u001b[39mupdate_pointcloud()\n\u001b[0;32m---> 22\u001b[0m     reward_list[i,j]\u001b[39m=\u001b[39ma\u001b[39m.\u001b[39mupdate_policy_grad()\u001b[39m/\u001b[39mhorizon\n\u001b[1;32m     24\u001b[0m a\u001b[39m.\u001b[39mpolicy_step()\n\u001b[1;32m     25\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m'\u001b[39m\u001b[39mEpoch \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m finished!\u001b[39m\u001b[39m'\u001b[39m\u001b[39m.\u001b[39mformat(i \u001b[39m+\u001b[39m \u001b[39m1\u001b[39m))\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "max_epoch=1000\n",
    "batch_size=30\n",
    "horizon=100\n",
    "\n",
    "a=Agent(lr=0.001)\n",
    "\n",
    "a.train_policy()\n",
    "reward_list = np.empty((max_epoch, batch_size))\n",
    "action_list = np.empty((max_epoch * batch_size, horizon, 2))\n",
    "\n",
    "for i in range(max_epoch):\n",
    "    a.set_policy_grad_to_zero()\n",
    "    for j in range(batch_size):\n",
    "        a.reset_state()\n",
    "        a.reset_pointcloud()\n",
    "        for step in range(horizon):\n",
    "            action=a.plan(pc_W=a.pc_W,state=a.state)\n",
    "            action_list[i * batch_size + j, step, :] = action.detach().numpy()\n",
    "            a.update_state(action=action)\n",
    "            a.update_pointcloud()\n",
    "        \n",
    "        reward_list[i,j]=a.update_policy_grad()/horizon\n",
    "\n",
    "    a.policy_step()\n",
    "    print('Epoch {} finished!'.format(i + 1))\n",
    "    mean_reward = np.mean(reward_list[i])\n",
    "    print('Normalized average reward at epoch {}: {}'.format(i, mean_reward))\n",
    "    print('Normalized median reward at epoch {}: {}'.format(i, np.median(reward_list[i])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjMAAAGyCAYAAAARVkUiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACu/0lEQVR4nOydd3gUxRvHv5eeUEJLoQRCD733LoFQRFBUQKQLgsAPBFRQmqCCBURAwUJTQbqIVKkiGOkoHYFQBEKoCSSQOr8/JnO3u7d7t9dyF3g/z7PP3e3Ozs5tm3feeYuBMcZAEARBEASRS/FydwMIgiAIgiAcgYQZgiAIgiByNSTMEARBEASRqyFhhiAIgiCIXA0JMwRBEARB5GpImCEIgiAIIldDwgxBEARBELkaEmYIgiAIgsjVkDBDEARBEESuxsfdDXA2WVlZuH79OvLlyweDweDu5hAEQRAEoQPGGB48eIBixYrBy8tGXQvLAebOnctKlSrF/P39Wf369dn+/fstlv/8889ZhQoVWEBAACtRogQbOXIke/Toka5jXb16lQGghRZaaKGFFlpy4XL16lWb5QyXa2ZWrFiBUaNGYf78+WjQoAFmzZqFmJgYnD17FqGhoWblly1bhrFjx2LhwoVo3Lgxzp07h759+8JgMGDmzJlWj5cvXz4AwNWrV5E/f36n/x+CIAiCIJxPUlISIiIijP24LRgYc22iyQYNGqBevXqYO3cuAD4NFBERgeHDh2Ps2LFm5YcNG4bTp09jx44dxnWjR4/G/v37sXfvXqvHS0pKQnBwMBITE0mYIQiCIIhcgiP9t0sNgNPS0nD48GFER0ebDujlhejoaMTGxqru07hxYxw+fBgHDhwAAFy8eBGbNm1Chw4dVMunpqYiKSlJthAEQRAE8fTg0mmm27dvIzMzE2FhYbL1YWFhOHPmjOo+r7zyCm7fvo2mTZuCMYaMjAwMHjwY7777rmr5adOm4f3333d62wmCIAiCyB14nGv27t278dFHH+Grr77CkSNHsHbtWmzcuBFTp05VLT9u3DgkJiYal6tXr+ZwiwmCIAiCcCcu1cwUKVIE3t7euHnzpmz9zZs3ER4errrPhAkT0KtXL7z22msAgGrVqiE5ORmDBg3Ce++9Z+au5e/vD39/f9f8AYIgiCeMzMxMpKenu7sZxFOKn5+f7W7XOnCpMOPn54c6depgx44d6NKlCwBuALxjxw4MGzZMdZ+UlBSzP+rt7Q0AcLGtMkEQxBMLYwzx8fG4f/++u5tCPMV4eXmhdOnS8PPzc2q9LnfNHjVqFPr06YO6deuifv36mDVrFpKTk9GvXz8AQO/evVG8eHFMmzYNANCpUyfMnDkTtWrVQoMGDXD+/HlMmDABnTp1Mgo1BEEQhG0IQSY0NBRBQUEUVJTIcURQ2xs3bqBkyZJOvQddLsx069YNt27dwsSJExEfH4+aNWtiy5YtRqPgK1euyDQx48ePh8FgwPjx43Ht2jWEhISgU6dO+PDDD13dVIIgiCeSzMxMoyBTuHBhdzeHeIoJCQnB9evXkZGRAV9fX6fV6/I4MzkNxZkhCIKQ8/jxY8TFxSEyMhKBgYHubg7xFPPo0SNcunQJpUuXRkBAgGybx8aZIQiCIDwHmloi3I2r7kESZgiCIAiCyNWQMEMQBEEQRK6GhBmCIAgi12IwGLBu3Tp3N8Nl7N69GwaDwWku9c6uz1MgYYYgCILwWPr27WuMU6bGjRs30L59e5vqzMoCXO36cvPmTfj6+mL58uWq2wcMGIDatWu7thEqNG7cGDdu3EBwcDAAYPHixShQoECOt8PZkDBDEARB5FrCw8NtigKflQX8/Tdw/LjzBBqRR1BKWFgYOnbsiIULF5qVT05OxsqVKzFgwADnNMAG/Pz8EB4e/sQZg5MwQ9iMu5z5n6wgAgThXhgDkpPdszjzWZZOM126dAkGgwFr165Fq1atEBQUhBo1aiA2NtZYPjUVOHx4L/r0aYagoEBERETgf//7H5KTk41lfvjhB9StWxf58uVDeHg4XnnlFSQkJBi3i6mazZs3o06dOvD398fevXvN2jZgwADs2LEDV65cka1ftWoVMjIy0LNnT2RlZWHatGkoXbo0AgMDUaNGDaxevdrif16zZg2qVKkCf39/REZGYsaMGbLtqampeOeddxAREQF/f3+UK1cOCxYskLX9/v372L17N/r164fExEQYDAYYDAZMnjwZU6ZMQdWqVc2OW7NmTUyYMMFi29wGe8JITExkAFhiYqK7m2IT164xtno1YxkZ7m6JZVavZqxAAca2bs3Z48bFMRYWxtgHH+TscQniSeDRo0fs1KlT7NGjR8Z1Dx8yxsWKnF8ePtTf9j59+rDOnTtrbgfAfv75Z8YYY3FxcQwAi4qKYhs2bGBnz55lL774IitVqhRLT09njDF24sR5FhiYh7355ufs7NlzbN++faxWrVqsb9++xjoXLFjANm3axC5cuMBiY2NZo0aNWPv27Y3bd+3axQCw6tWrs99++42dP3+e3blzx6xtGRkZrGjRouz999+XrW/evDl75ZVXGGOMffDBBywqKopt2bKFXbhwgS1atIj5+/uz3bt3y4517949xhhjhw4dYl5eXmzKlCns7NmzbNGiRSwwMJAtWrTIWP/LL7/MIiIi2Nq1a9mFCxfY9u3b2fLly83qS01NZbNmzWL58+dnN27cYDdu3GAPHjxgV69eZV5eXuzAgQPGOo8cOcIMBgO7cOGClStmGbV7UeBI/03CjIcQFMQf8rlz3d0Sy0hfSDnJK6+457iEfWRkMHbuHGNZWe5uCcHY0yfMfPfdd8btJ0+eZADY6dOns+sbwJ5/fhA7eNB0f/7xxx/My8tLtYNljLGDBw8yAOzBgweMMZNAsG7dOqvtHzt2LCtdujTLyj7Y+fPnmcFgYNu3b2ePHz9mQUFB7M8//5TtM2DAANajRw/ZsYQw88orr7A2bdrIyr/11luscuXKjDHGzp49ywCwbdu2qbZHWd+iRYtYcHCwWbn27duzIUOGGH8PHz6ctWzZ0ur/tYarhBmaZvIQUlL45+bN7m2Hp9KkCf/01OClSUk5f8x9+4BGjYCDB3P+2Nbo1w+oUAH46it3t8SzWL4cGD0a2LHD3S0BgoKAhw/dswQFufa/Va9e3fi9aNGiAGCcJjpx4m9s2LAYzZvnRb58eZE3b17ExMQgKysLcXFxAIDDhw+jU6dOKFmyJPLly4cWLVoAgHG6SMw41a1b12pb+vfvj7i4OOzatQsAsGjRIkRGRuKZZ57B+fPnkZKSgjZt2iBv3rzG5fvvv8eFCxdU6zt9+jSaiBdiNk2aNMG///6LzMxMHDt2DN7e3sY228vAgQPx008/4fHjx0hLS8OyZcvQv39/h+p0JS7PzUTYRq1a7m6Ba3nwAMiXz/b9slN5Qce7I8cZMwaYMQPYuBHo0CHnjtu0Kf9s2ZLbIbiSpCTg7FkgIACoVs16+R9+4J9TpwJDh7q2bc5kzx5g2jRgzhygXDnn1//bb8CiRUBICNC6tfPrtwWDAciTx71tcBXSnD/C0DUrKwsAkJz8EIMGvY5hw/4Hb29+HgQlS5ZEcnIyYmJiEBMTg6VLlyIkJARXrlxBTEwM0tLSkJoK3LvHywcFWT+B5cuXR7NmzbBo0SK0bNkS33//PQYOHAiDwYCHDx8CADZu3IjixYvL9rPFqFmKs9JVdOrUCf7+/vj555/h5+eH9PR0vPjii06p2xWQZsZDEC+2SpXc2w5riMTlpUrZvu9PPwH58wMffeTcNrmbjRv55x9/uOf4jx+7/hibNwP16wOSAW+uI39+3nENHqxdpkULYMsWwFXv7EWL+OeqVa6pn7BO7dq1cebMKURFlUP58uVQrpxp8fPzw5kzZ3Dnzh1Mnz4dzZo1Q1RUlMz4N1smsokBAwZgzZo1WLNmDa5du4a+ffsCACpXrgx/f39cuXJF1o5y5cohIiJCta5KlSph3759snX79u1DhQoV4O3tjWrVqiErKwu///67rrb5+fkhMzPTbL2Pjw/69OmDRYsWYdGiRejevbtH5/UiYSaXc+gQ1wacOGG53L17fLT84IFjx8vI4LPely7Zvq/wQnzvPdv3vXiRf7pLYLCE0FSUKJGzxx0xgn+OHev6Y50+bfq+dy9Qrx7Qp4/1/W7edF2bbEXc+3v2aJcR2hhXC23ifgaAzEzg+nXn1a3wEH4iSExMxLFjx2TL1atX7arr7bffwZ9//onBg4fh6NFj+Pfff/HLL79g2LBhALh2xs/PD3PmzMHFixexfv16TJ061bi/PR7NL730Enx9ffH666+jbdu2RkElX758GDNmDN58800sWbIEFy5cwJEjRzBnzhwsWbLE6P0lZfTo0dixYwemTp2Kc+fOYcmSJZg7dy7GjBkDAIiMjESfPn3Qv39/rFu3DnFxcdi9ezdWrlyp2rbIyEg8fPgQO3bswO3bt5EibB4AvPbaa9i5cye2bNni0VNMAAkzHoPoLG7ftm2/+vX5qLl1a+DyZW2Xx65dgd69TQJFbuPoUXe3wPUkJpq+79wJfPklcPiw+9qjRWIiF6KlAo6SwoVzrj3OREzdqXiluoxnnwWKFwe2b3e8roULAV9fk7bwSWH37t2oVauWbHn//fftqisqqjrmzfsdx46dQ/PmzVCrVi1MnDgRxYoVAwCEhIRg8eLFWLVqFSpXrozp06fjs88+M+4vtNO2EBQUhO7du+PevXtmQsHUqVMxYcIETJs2DZUqVUK7du2wceNGlC5dGqdPA//9J6+revXa+PHHlVi+fDmqVq2KiRMnYsqUKUZtDwDMmzcPL774It544w1ERUVh4MCBMtdzKbVqNcbAgYPRrVs3hISE4JNPPjFuK1++PBo3boyoqCg0aNDA9j+ekzhsmuxh5FZvJmHl/9579u0nlvLlGVPxEHSbF5KU0aP58S04JmjywQfub78WwcG8XYMH21/Hpk28jpEj+e/+/fnvjz7S3mfECF7m3XftP65eJk0ynf+JE61fi9KlPe96ifZUqqRdpm9fXubjj+07xrlzjCUnm6/fto2xBg1MbShQwLxdzz1n3zGliLq8veXrLXmQPG2kpDB28CCTeTPZQlqaY/vbwqFD/DipqaZ14tjOuJSpqab61MjKymJly5ZlM2bMcPxg2ZA30xNOdDT/rFzZsXr+/RewU/uqi4IFuZrVnpFrwYL8MzTU9n2jovinGDl7EkKjsnu3/XXMm8c/Z83inyJo6MyZ2vt88QX/nD/f/uNagjHg44/NR/kS8wFN2rRxTZtczbFj/PP8edv33bePe3CpPRtt2gD79zvUNJsID7etfGYmv65paa5pT27k7l0+fS+ZdQEAeHlxhwThlOAuHDUZACzb2926dQtz585FfHw8+vXr5/jBXAwJM05g1SpuMPjNN+5uCceSPUvevI7VLXKTnTzpWD16OHcO+PBDYPFi1x/LGZw5A/Tta1+HIFLLdO0qX5+aqr1Pz57801XGqjt3cnucZ58F4uNt29dTngVbEcLM2rW277tiBf/M9u7VjZiSc4Z30+uv889Bg2zb77//gCtX+D2cG0hPd31E8IsXeWcvtW8CuAHwzZueZQ9mLz4W/JlDQ0MxZcoUjBv3DZKSCuZco+yEhBkn0L07sGaN6UViD+IlYqvNzJ493LZCilrMk//9j38Ko1F3kC8fUKwYkJ3fzCqnTwPjx/OOUQhRZ89ql/eEdAdLlgBbt+bMsUJC+Ker7FOuXTN9//pr1xzDHs+QnCA7NInLGDjQ9L1GDf5pj8bSWYjnyxWamawsruVwlmHynTs8t5JUA52Wxu9XW4VuPbjzHhXvNFcZdQv7Hy8VSYAxhgsXbiEm5hWnaIFcDQkzHoIw8vrtN9v2a9YMeOMNYNQoy+VmzOCj/MmT7WqeU3jwgHtt6M08f+MG/4yN5VoCALh1y7T98WNuGMwYn3KJiLBvekCKPW7Oyrgr9sTR8XSybSMBOG9a69QpoFAhYPp02/Y7e5aPzO3FknZS2FD26mVap+K1qoqfn/42eJqBdJEi/DN/ftv2u33b+vN88ybXbkiFY0cQ70rpdGdyMn9fKI1l9ZKYyN8tas9/QIB9dToTtYGaq9uVlmY6bm7ISUnCzBNChQqWt/v48JetJbWip3HggPp6MVJq0waoXZtPQ40cyV+Wjmie1qzhEYaFLYpehD2PIwjNx5o1+vfZsIF/6hWA//4b+OsvrrlLSrJtOmTcOP1l9bJnD+9ENDxGVVm+nJ9vMS1nC7ducY8/S9F3796V/963j0ernTvXev3SaSLl1MTZs8Dvv5s8Dt95x7StWzfgrbecex9NmqQtmGdm8vZJ/6sYoUtizVnl8WM+pW1tAOFsjalaG/UKnFokJPBrI9VAFCrEP5WaZHe7vtetyxdnDJrEeVNqnx4+BP75h9tgAsCjRzkTz8oRSJhxMmPGAFOm5NzxunXjUrMihpKR9HQe7r5rV26YOGdOzrVNiXgw/v7b9n0bNjR9L1CAa2REktpvvgEqVuTf7enkBMIGZeRI++sAuD2RrWpZW1XZWVmmTkSv+3bNmjz9we7dfCRepox5pyulTRsuxHz0kbqxo6OemiL6rC3TK0KosCcdQJEiQMmSljuB9ev556lT/LNXLz5CHT7cev01a5q+K1NMVKgANG/Or9XEifJ4SStWAJ9+ar+9SmIisG0bfx6kAQGFMbmShAQuyFi69npwpFO3JOCkpVmOaC2EDPFpK2pTKk8rUiEwKYlrtxhTN3dQJP72OOiyOpkZM/ioyN6Rgp5Q8VLEqFaEj1eSmMhj0axdyzvZ2bP5y0yE485JRFvtySUkneZ48EBun5SZaTJ6LlDA3tYB2TGz8MILtu23aZN5PSVLcs3D3Ln6RqbC/kVQrx7/fOkl87InTzr2Pw8fNk3TWPLAKlqUCzLjxtluy5XbWbLE8nbGuPAh7dD12Nn8+itP8fDnn461T8rp00DbtuZBDLU6H7Upuuyo+maaKUsoNSQZGVzbZ02Qv36d34NKL6FHj/iU1T//8P/06JH+tlgjMZG/9x494hrq6tXlgRGFR6L0mGFhQNmy+m381MjI4P9JOlh5/Jjb9uh5psT0jvRc37/vPBskMTXq5cUdLq5d05429ASbREuQMOMhCBW1MyKPWko1cP48f0gLFXLs5lR2vu6gUyf+efCgZa8fvQgBQdgP6EVNa3H/Pg+NP3w48MEHfPQtRvtqCI8kIUg9/zzXoqjlitu92zlumbbwxhvm6/76S72sXkH50CH+aYvBtFZurv79gSpVzAVLKSVL8s7BFs2b8C6Tal0Arg2sVAno0YP/vnLFsgNAvXr82CKdwc8/8047Pd1kDyY8qWx9LoWdiCOaFtHZ2nJs0dGKz6tXuXGu0khf2L7dusX/s4h2rAwhcfKkfMrKmfnGLl7k1+j2bd5ePz++KG1BpMe8eRO4cEEezNJWzp/ni7AXysriAtN//+kLcaBV58WLjrXLkiZY613qiFCXE5Aw4yB376rfGM5UZY4cCXTuDBw5oq+8dNRuaaRljzAjwnLZ+yDai14V5z//uLYdatSpY3n7xInc4+3nn/XXOW4cH7337m2+TTlN8u67+uu1hbNneSceHQ1Ic96JfHiDB/N74b//eKfcuzePj6PXxVh6rfR60Qhhv2NH+fpFi7iwaMklXHSeeoQnYVwpUlQoc6aJDlo8B1FR2sf+7z+T4CbYv597MQlhCODnOyUFKF+eZx3Xi9SwVmqcrZVEUhhAS99RwvDX3qkbQNumQvqe0brOaloYLfsdoUWyRbssNOVJSbw9jx/zxZ53oC1aStFWsc/Ro1xAAsw1UwAXpsQ+1rDXy+rOHd6XSJ0pAJOWJm9e9azmnm5vScKMA9y6JfdKcMRIUhhjqj2gX3zB5/JXr9ZXlzRol56H9ZdfeHA0d6sRFy7k6nLhWt6sGf/Mm9fcLkRL+2RJmBk7lnfMWp4wwg7Dnhgjehg/Xv8U1r59/JpYyiNkL9LrbCmx6f793L5pxw6ubheIUABHj3IX44gIrhX54Qfb0mVIr4NezVqRIlx4dCSjtR7blGeftbxdBIAU05/KzliM+A8c4OdHC6XB99q1vLNzRmwlrVQ6wtjXUW8YISCI+8mRDNxqcau0nlMhjNkreKWl8WB41vLZCe2nUuho3DgSy5bNsu/gFmCMT69Jpy8tuWZfvmyu3Vq8eDEKWJmDFu7rN26YhMusLLmWKjSUa99//XUxWrUy1ffgAReGPBESZhzg00/lv6XGp7a6sgkV8eXL2mX0vvDV4sxYoksX3tG7Oonja6/xTy0j3QEDuCHjxx/z38uX88+UFLmnB2M8UKHaAy7tdJV8/DHvmLXy1gg7Bnti/SjR6mzVtDMbNpimcYQg9eWX/JqoTTPpMfhNS+O2UkOGqG9PSOAvNa1pGyVSAUhkPT9wAFiwgH8Xxt22ILUr0zv/37gx1z4MHWr78aTs389d/rW0Cfnz83OYLx8X+IQ2SosOHdTXWxNKbI3UqxcfH5OgOmAAF6LFNcyfH6hVi2uAhMAgttkzzSQQCZX1TkdYE0YuXZLfI7GxsfD29sarr3Y0K6tXMEtN1f8fxbmxZUqXMS4kiHew0C4Jbary2A8ecO15bOxheHkZcPw4n7tVPg8dO7bGCyojIXsC9wlZp0AB6+eiTZtuWLPmnLHto0dPRqNGNZ1qz+QsSJixk23bzF2Hmzc3fbdVBdi2Lf9UGgDbY6irN6O18mVkLeAUY1ztbjDIvYuknD+vbfwsbEuE6j4+nnuLKKOVirlg4XIcEsJH/gDQpImpnJoaulEj0/fUVPW4E1r/U1wDNYHI0kOv9kIpWpTbaCgRqv1XXgGee47XK2x/pPz0k/bxlCNKkfpAyubN3JZIKyZMSAi/HnpdcaXTitL7XmgopOhNClqmjOm73pfjhg3c/kSP3ctLL3HVudo5eOYZLhgp7wXxol+4kE+tDRjAR8vKGClC8F21in8q7w9xnZW2NmrtEJw9CyxbZrm8XqSCwsKFfApOCG6pqfye/ftvvmRkmK6vLe8b8R8tDdzUpoe9vblAdfmydbsPaae+YMECDB8+HH/9tQe3bl2XnXMfHy6g1a5tuT6t97KYQtETZ8fS/71/n98r53j/bxTspFqrzMxMZGU35MYNPpAtX74OatSogfXrzR/m69cv4fffd2GAnVmC4+L49bcmuIjB8uPHXJC7excICAhEoULc3dBgMLeT8iRImLGTtm153AhXY48q1RUudOfP81GkeKlL88x8+SUwejTPI1S+PH8x6IlJcOIE8OOPwLffyqMYCzW4eDGVL2+5Hqmnk5SaNbmKX+kKPmSIunt4/fr8U2nzkZXFO77nnrPcDsHIkdxO5uJFdY3D48dcWPn1V3NNnDKdgR7atTNfJxUot2yRb4uM5FrFiRNNth/W0FItly6tb381xPm2BWFAq8frJiODv5SHDDEFw7OG3oCOQqAT51mpmRJ2VNY0OoBJo3H6NBdCHUEYISckmBtDGwxcE5CSkm2Eyxi8HiXj8Z1keD0yLexhMh7EJ+PUQf6ZdCMZ/51Nxt2rydyoQ7JI98l6wL9nPTBtv31ZXrfXo2SEBCUjPY33rOK8WfPOe/jwIVasWIEhQ4agadOO2LBhsfEeSEgAlizZDR8fA3bs2IE6deoiKCgIjRs3xlmFNfKCBR+gZMlQtGiRDx988BpGjRqLmjVrGoWNl19uiZEKSXnkyC6yjNRKgWjmzJmoVq0a8uTJg6pVIzB9+htISeGGL8HBwB9/LEalSgWwfv16vPxyZTRp4o/4ePOXdP/+A7Bt2wo8fpwCHx+ThnjDhsUoWrQo2rVrh9TUVMyaNQYdOhRHs2Z50LdvAyxatFs11o8QXr7+eh7ati0Lf38/VKxYEatWcdfXzEz+rn7w4D4++uh1xMSEoUmTADRrVhXLlm1AZqZ8mumnnxbjm2/ex7///o3AQAMMBgMWL16M/v3741nFvGx6ejpCQ0OxQKhucwAPN+l5ehDaFL0W6klJPPBWxYp8+uatt0zbpC9kNUMugVK61hIKAO5irGX0K1yale1Tqn6V6Qyk02ZSV9W2bXmHLwye9+41hX/ft4+3u1s3kyFnmTImDwnpPLuwjfj1V1PIeMG33+oLhAbwUY3w3HnwgAs7nTsD772nXn7WLD6VJaITS8nKkgs4zvAQsOYS3L49b8eXX/Jr2LKlSftUr566ZkgvSoPOqVOBCRPk606d4lqgXbv4saTGxAK9Iz0xpaflSfXLL1zQbtCACwcCpau1sIO4fZsLd9aw5IkGmAeO0yvknTrF2yp1kS9Y0LbAjVr2Y+vX8+kvISgkJsqFXK/HKajdnBugKCNC5AMgzXmrprDwAyBVhIRlL1K0FCUJex4CgdaNbMR9sXLlSkRFRaFixYro2PFVfPLJSPTtOw6AQSaQv/XWexgyZAbCwkIwc+Zg9O/fH/uyg3Bt3rwUixZ9iNmzv0Lhwk3w22/L8e23M1C2rG0SubkWzguzZ89G6dKlcfLkRQwd+ga+/PJtNG/+FYKC+Ds4JSUFH3/8Md577zsEBxc2ajvEdNSjR0DPnj3x1ltvYceO1WjYsDcuXeIpBTZuXIIOHfoiOdkbo0cPxvHjp/Dhh8sRElIMu3b9jMGD22HduuMoV8406ktP5/f/gQM/Y8aMERg1aha6dYvG7t0bMGZMP8ydWwJ167ZCeHgWRoxoj+TkB5gy5UcUL14W6emnkJzsbfa/O3fuhoMHT2Dfvi3YsWM7AgKA4OBgVKhQAc2bN8eNGzdQNPtltGHDBqSkpKBbt242nVtHIM2MHeiZc/30U/4CHztWX51CLWnJtRTgnXxCAn8Zz5/PRzZjxminM7AkzJQvz1XxwhVZbcrg/n2uIbHVEFUrlsX16+qqbKV6/YMP5L+3bZP/vnDBJAyJ4HmAKdkfYDKEbtyYf6ppMKQIbY1y+lBqDzF4MJ++GT/etE4tcuu//3JDRbUAbcp1YmSuxbVrwHffcaHs5Zf1ucUr1eVTpnAbismT5dM7eu2DtI6pnPKqVcu8zO3bQKtW/F6TCjqumncXHmCW8ngJ9NpD2BPoEbA+dXvsmLl2bNAgeToFawhh1ppQ5skRXLWmd8RU1oIFC/Dqq68CABo3boeHDxNx5Ii5anzQoA9Rp04LlChRGcOHj8Wff/6JI0f4H1+5cg46dx6A3r37oVSpChg4cCLKleNiXHAwv8ft8UIdOXIkWrVqhcjISLRo8QyGDPkAW7euxNGj/H13/TrXVHz11VeoUaMxIiMrIiBA/mJOSQEKFSqEli2fl001HTq0C9evX0KHDv2wZ88VLFq0CNOnr0KtWs1QokRZ9Oo1BjVqNMWqVYtk9T14wAcac+Z8hmef7YuXXnoD5cpVwKhRo9Cq1Qv48cfPAAA7dmzHyZMH8Mkna9GgQRuUKFEG7ds/i5YtzQ0bHz0KREBAXnh7+6BQoXCEh4cjMDAQjRs3RsWKFfGDJNjZokWL8NJLLyGvo5mNbYCEGRuZNElfcKx9+7jQoeyE1bAl8mdgIBeSlCNTrZGgJXe68+e5h9TRo3y6Q206Z8YMvl2vHYTAluBbSlq2NA8q5oyOT6rCVxMyhGeJiPchkHoMqNk0KLU+tiJ1v1ZLZ1CrFtdMPfcct9GQCmwA13goadJE3tZJk7h9xj//6Hf9lCIV3iyh1RkcP84/hVE3IBd4Bw3SP8WjhjTarT3TV7YiPIViYvin0pNHTPUqXbIBPgMzbZrpt5+fXLP68cdcw6SXqlX5cdavV08IqnVeswKCcGTPQzy69RA3LzzEkT18uXvlIc4c4t/PHn6Iv/eZtuGhaUm6blovXc4fM5VRbrvwN//MUnTmanZ2oaH8fjp79iwOHDiAHtl+7AEBPmjTpht++cV8CqN8eVOgrrQ0/qK+fp2rlC9fPouGDeU3R5Uq9ZGZya/XrVv2hdnYvn07WrdujeLFi6No0XyYNKkXEhPvIDk5xXiP+/n5oboiiJhSG3n1KvDcc/1x9OgeXMj2316/fiFq126BiIhyOH/+ODIzM/HiixXQvHle43LkyO+4epWXT0/n/0E845cunUaNGk1k/6N69SaIi+Nqy7//PobQ0BIoVcqUD0ePvaeyzGuvvYZF2XPAN2/exObNm9Ffy53ORZAwYyNTpuizIP/1V/6pJzaMVB1uCakx+/PP80/hUqflTaJlqCvl/HkuUIkpg9RUPnW0aZPcoNZRhPu5tf974oS5YarenEVbt/KOW42ZM03fhdt3TmBJoDxzxnz6Tqn5U8aDUKI25XLkCJ9KU1Kjhrrwo0arVnwKc/Ro9SlIofGS0qGDuRGm1uBMqu3ZsIHfhydO8HtP6SlojREjuOCdUwhhWIRmkBr/AyaPM6HVkwrPs2fLPdKOHzf/v126mL4zxu9rLfumzEyudUlL0/ZeU8VgQFZgHqT75QELyoOsQL6woDzIE8q/i0+xII9pyQyQbxPL/XS+Xbm+cMk8KFs9ux5FT64mYAcG8mILFixARkYGihUrBh8fH9So4YM1a+Zh5841uHw5UWZv4+MjfXHwY2RJel4fH3MhQtoxe3l5gSkewMeP5WpmqXBz6dIlPPvss6hevTrWrFmDLVsO4+23uQFgenqacRrJzy8QBoPBuG+1aubPeWYmUK9ea4SHl8T33y+Gr28Sdu1ai86dueFvSspDeHt7Y/Xqw1i69JhxWbXqNEaP5vOSd+6oxwGLijJp6YUWLDQU8PY2Vwvb6g0LAL1798bFixcRGxuLH3/8EaVLl0aznHzJgoQZm9EjHNiKtKPYtEk7kqjUk0fJ7Nnq6/VofV5+mY8whTHqV19x+4qOHfUFSlq9Wj7i1kJoCqyFcr99m3v72MuUKTzomJgCEcbKwqW4YUP+4rA1Q7kW1vIEzZ2rLcCNGWPurr11q8kI2l6aNtUWWqTG20pWrOA2S7ducePpb78FPvtM+wWnR4scEmJKz9C9u2m92n88epTfe1r2SJYQndKPPwLvv29aX7t2zsdQsjS6HTdOPWaUlofWmjV8irRYMblHieDkSX69leYJX3+tnbNNyqNH8si3ejVk0neDmlecsGOzhOhY1c7X5ctAamoGvv/+e4wfPwM7dhzDsWPHsH37MSxd+jdCQoph/vyfULKkehRuJaVKVcThwwfh52fyjjx9+qDMhq1AgRDckEiNmZmZiIvTDkhz+PBhZGVlYcaMGWjYsCHKlq2AW7e0/7j4n8r4MAIvLy906tQPP/ywBBs2LIOvrx+eeYaHB69YsRYyMzPx338JiIgoJ1uKFAnPbq+8vsjISjh+fB/8/PhUVmoqcOjQPpQpwy2iypevjoSE/3D58jnJf9ZsPnx9/ZCVlWmmrSpcuDC6dOmCRYsWYfHixehnS9RHJ0HCTA7z4IH1vE2LF3PhwJ5keoDlIF1qiJG/0Djp8YaSjjS7djV/kTqCcppHC2UUWCnS+B5i1Cc8ct5+m0/ZxMQA27fb1jZpWH+hyVIzaJXy999yux4paoLd+vXmeXaciaXr2707nxpVRhVWus8D/NxZiusjiIgwTWFKp2jF1JO0PjHlphUwTYtRo+RTNZMnm75b8ijSm+NKaRclYjIJAV3r+gohSo9tjlb4fksRi1NTTf9VRJaV0rSp9eMaDOZed8KWytIUi7XpF6W90K1b5obUSUlcgNU6Pxs2bMC9e/fQuvUA5MlTFVWrVkVUVFWUK1cVzzzTFb/8sgDnzunTlr/88nCsWLEA33+/BP/99y+2bPkAFy78Ay8vk3RYp84z2LhxI375ZSMuXTqD6dOHIDHxvmad5cqVQ3p6OubMmYOLFy9i/fofsHatRjwEmIR/pcCYN6/p/dSpUz9cu3YNM2a8i5iYHggICES+fECzZhXQs2dPTJ7cGzt3rsW1a3E4efIAFi2ahr171YNn9er1FtavX4xPPpmH3377Fx98MBObN6/Fq6+OAQA0b94CtWo1xzvvdMX+/dtw7Voctm7djPXrt5jVlT8/ULx4JK5fj8Pp08dw+/ZtpEq8OF577TUsWbIEp0+fRh9XvsA0IGEmB4mP5zdE3bp8ZPbSS/whVka/TEvjYc6lo0tA7n2jFsNEYC1JnhbCzkU6Ylbz4khP1xePYscO/h+0XsYVKvDRXeHCciPY8eP12SXpRWrwCsin67SmcLQCFErPu78/70DUplukzJtn8sbSw7x5ljM7K7FViyFNSrpggbrWIjiY/7e2beXaFCnvvqu+r1JYz8ribvIdOsiNVJVGtY5E0P78c+1tlqL5Fixo0nZIwwMoUcaLEQHpROZwtc74/n3L8YKUqE0LApaNj+/ckWsY583TfzwpSqFOXEO9+ZH02nmqhfC3NLibO3cBGjeORt683O3v3DnTuX7mma44ffoQjhzRl8Okffue6NNnHEaOHIOaNWvjwoU49OnTF35+JrfLF17ojz59+qBfv954/fUWKF68DOrWbSWrR6pFqlGjBmbOnImPP/4YVatWxapVSzF06DRooWWvJh0QhYeXxDPPROPevXvo1InbnZQuzaeFFi1ahA4deuOLL0bjxRcrYsyYLjh16iDCw/mLSakha9myC0aP/gLz53+Gbt2qYNmyrzFlyiLUqdPSKDx9/PEaVK5cD++91wPdulXGJ5+8jaws84vi6wu0bt0VjRq1Q7t2rRASEoKfJDd4dHQ0ihYtipiYGBSz5BrrIgxMOUGYy0lKSkJwcDASExORX08EJBuRqnirVFEPw20wyF/y4vt335l3auPGyY0BpTRtytXLeo0vpYhj2hLcaNUqnvBw61Z+3Fq1ePh/5Xy+WoAw5bq4OK5d2LOHC28HD/KpdvEyU5afMEHuwbRtG9CmjXZbO3Tg/00rmi8gXCK53ccff6h7t+zaxe2CEhLkgkp4uMlGQXoOr17lkWNffpn/fvllrspXBlVzBXnyqHcub71lavvgwep2AZZYtsyUI+iZZ/g5Wb6cC3RigFWpkmmqrH9/Hoitfn1zzy+A2+VIO+BLl/iU35kz3LhbxGBp2NDylJfam0n8r6JF5dMY9gbxioszGc+3a2cek0fQvbtcMJk9m9vpiPXK469Zw7UFagk69SL+/+TJ5gMbsW3hQn0pJEqVeoz58+NQpEhpAPKYCUKTK6Y+ChY0DVby5+cDjZs3+fcKJjtRJCWZvDB9feXatLp11Y2f7SE4WB6yws9Pfy4va4wY0QbBweGYMoVL+Hny8Hv97l154k5ppGzhoQTwe1l67R8+VJ/a9/HhArHWOYmMlAc7rVaNv1PEALNiRf4+8/ZWryMoCKhcmb8fEhP5IE1Nu+nlxc/f48e8TYUK6c+zFxnJ75HMTG50rgy98fDhQxQvXhyLFi1SjVYsePz4MeLi4lC6dGkEKCpxpP8mzYwNKB8gNUFGoCaYSvM4CSzdSHv3OtcA1xqMcaFDOnqw5jYs9lOSkWFy5xYPn+gYW7UyL690m7Y0384YF2KsTUWIEdT9+5bddGvVMtd0abnUDhliEmQAYOXKnBFkAO0pnTt3eHbu4cPVR77W0JMeQa28miCjRnw8F5jGjJGnzLA23aokMdH0Aq1Xj6eMkF4LNawJOdLzpSbIfP+99XQGjFl3+3cES//BzqCwskjjyudIGs4hKclkGyMSEVrD2dmVlbZV0vewMmK6peM/fpyCpUtn4sKFk7h06Qy+/noS/vxzOzp2NJ8S0TrnmZmWr4eyjxBtz5PHcjoatRAaUo/Qs2f1ZUXPk4f3PVqa7awsUwiOQoVsy0wujVMk/S9ZWVlISEjA1KlTUaBAATynN7qok8kRYebLL79EZGQkAgIC0KBBAxyw8ha8f/8+hg4diqJFi8Lf3x8VKlTAJmsBWDwIxkx5iIYM4aMaX1/bphoEeuf0ncHKlXy03acPMGcOD8qnZpBuMHCNjSVeesl8negQRKd88ybXJIwaZf5C1Rp5SYU7a0KEiKthyV7hxx/VjXO1zru9dkzOQCuJpnRa0VE9qxBkledf+mK1FnNFuV3rJS7SWuiBMX5NxDVdv55Pg4l0Apb2s4RySlYZgK53b35/KIVr8QpbvpwbnyqjgW/a5JhWRi+2nEMpShsTqfCunArJm5drKpVCgnRKw1YbJ1uwZJCstFerWZPbZ6mfFwP27duE119vjl696uCPP37Fxx+vQYMGppeZmN5Vy/WUmcnte9TeO3fucG2IVDj29jZ1/nnzWo7ppByEqN23iYnqyTHDw02egVlZ/Jh6BU9buHfPJJxJz/uVK1cQFhaGZcuWYeHChfBxU3ptlx91xYoVGDVqFObPn48GDRpg1qxZiImJwdmzZxEaGmpWPi0tDW3atEFoaChWr16N4sWL4/Lly1YzgXoaL77Ip6HKluXTRRkZ6iHhrU0tCpW8K+jVS24/ITwskpP5y7hcOe0Q/tY6daURb0qK+XTZ8eOmuBhKmwctwS82lj9UBQta1oxJsWRAqRVtW+tloDfezYoVfCqMMX35XhyhaVPHUmtIp/MOHuSfa9ea3P8B+xLaCdavNxnKzp5t8tpp1AhYt876/uvWmQYHalgTaCzxySfy35YSvUqRegmp2V3pieIejW14jADshWUXVksG8VWrqucfs4ZUI6ycIlILrqfmRWVJe+FMbMlz5+XF37Vqz29AQCC++sqyxb/opNWMm9UENpES4Pp1LrRLvaqk5yFPHutG4IUKmQYNWsbVatdGRFsPCeHPqbVBnvgfWVn6vFWtERkZaebO7g5crpmZOXMmBg4ciH79+qFy5cqYP38+goKCsFAtOx6AhQsX4u7du1i3bh2aNGmSHVWxBWo4Gpksh6lShavA69QxD3UuxZqaXIs8eawnsQMsqyaVsqQ0E/HmzdzTxlkJxaTBvIKD+YNvT/A2gD/0enPt2Et6Oh+1603aqaRfP36NciIApjReS/Xq1uPSKFG7xuvWWb5vtfjf/8zXSeO/CK8ZZYcnDXqn5PnntXNDAfY/Q7Zgz7mwRGHcxja0xR9ojpbN1Xtrca4sdeZ6n0/GxGifoRDuoApOIAC8Z1R2aMp+6eFDbj+m1JBoHdvRsAK2oNQCXr7MhT9Hp36lmgdvb1M8LyXHjvFBldA+avXpgYGWo7E7EhQ0JcUk5OgJVio0RLdvmwd7zAlcJfi4VJhJS0vD4cOHES2Zk/Dy8kJ0dDRiY2NV91m/fj0aNWqEoUOHIiwsDFWrVsVHH32ETA1xPzU1FUlJSbLFVejNMAzw3CplyvBkflrkyWMKuW8rKSnaIzaptsfS/LUyyJjSpufwYVNsFi303pdSweXaNa7OlY78bUVN3arEEY3IvXtcYLI3kWJKCh9dWXNfVcvya0kLoYY0ZsmVK8DSpbbtL5KZKl229drESFEm6VRy9Sq3ocqTB/jwQ9N6S95IagJSTiM0Vs6iCExzDnv2qD9EavYMJqGEf+rVyN2545s9dZiCMohDIB6jFC4BMAWzFCg7bSFU3b4tnzLUmgpOTMy51AlKbYkQei3Zp2hRpIhpekna/sxMy9ovqSCiZQN5545lIS8lRW6faIs2CrDfINqWPg0wDUIcmVZMy26st5OlXpdOM92+fRuZmZkIU0Q0CgsLwxmNaG4XL17Ezp070bNnT2zatAnnz5/HG2+8gfT0dExSCe06bdo0vK809XcRtmgp9u3jLwlL6QySk10TzEuoPP399Y+SOndW77h37tTeZ9Ys/e0XQaoAPlXkyjl2gSfnohGoRYj+7jvH6lQzNLfE+fPcW0OZJsHS9JwWeoyJhwzh96e0w9E7veNOhGCanAy8+qp5/jBbyBMEQGIn8dZb5l6Djx/z6b7169Xr6NJFv8F3crI31q8vgB49EnClQBBCkIIE5Adg/pBYikB9/Di/vwoXttyBOpLOxF3cvs2np3x9zd8djx/bZiyrJDXV8pROZqZ0wMeQdi8ZXghAls4uOiODt9GaEOTlJS9jj9AHcAHOVkEI4MbCt27dQlBQkNNtazwua3ZWVhZCQ0PxzTffwNvbG3Xq1MG1a9fw6aefqgoz48aNwyhJlsWkpCRE2Bo1zgWI8Pt//cW1L1qahJUrteto1kzu/SHFmhDx4AF/eKwZ6gp++cX2KZE339RfVjpicVWCQSlRUbblvHqSGDzYtvI9enDNiK3TU2pMmcKnVm31kFLDYOCu3IqUNprMmMFTL7gK8cw9eiTXKtlDskIIUUvf8PixKQeUksxMbSFHi0WLeJTYwc+dQrJfGu4YsvAQiWblpIargHmoCdHpBwdrG7WmpqrbiKiFF9AKOeAOsrK4Zik5Wf7fbt82X2cLt29zDyM9++dDEq7dvgdv+CIB+uO1xMXxZ9iSkKm8tg8e2CfQeHnp83RV39cLJUuWhMFZNgzZuFSYKVKkCLy9vXFTYT148+ZNhIeHq+5TtGhR+Pr6ylRQlSpVQnx8PNLS0uCnsOzy9/eHv7UQrE7CXm3CSy9pCzNampsOHbg2Q0uYsYYwTLMFW6cnbEGaM0ZvXANLWBPmnnnm6RVmihZVjwZrCXumlHKC3bstx6LRS5ky+lxb9fDHH45rVG8iDP+A+xWz7BxC+fLJBQCtGFYAn8a2FcYMWLiwKJ5d/ibaF4nFIsMUrIT10N1586rbt1kaMCidCywxf77tAriUkiX1RS3XQ79+3Itz82bzwdqiRY61c8kSffuvRleUBr/4naH/JbZ2LTdo17omERE8Uvtnn+muUpOFC3lcG3vw8/ODlz3pya3BXEz9+vXZsGHDjL8zMzNZ8eLF2bRp01TLjxs3jpUqVYplZmYa182aNYsVLVpU1/ESExMZAJaYmOhYw1V4/FjMWFtfwnCD+SLVarnKldXX9+7N2N69+o+nXF56yf59Zf8jzDn1OHupXdv9baBFfalTR/47IkL+u1Ej97fRkaVr15w5ToMG2ttiYuyvV3xZiy521xEVZXn78OE5dz3at7dvvzZtGOvTx/ycZ2Ux9tNP5uW3b3esnVu36iv3BuYyBrBNaGdc17Ch9f0qVmSsRo2cOednzji9e2WMOdZ/u9ybadSoUfj222+NORuGDBmC5ORkYyKq3r17Y5wkjvmQIUNw9+5djBgxAufOncPGjRvx0UcfYajU1cbDqex1BvEoir9Rw2pZtXQBAA/WJaKyqmEt3L8j7qpS1Fxy9SaicyV6spHbQhHcwiRMRknkAuMND0c5xaRMqhfdOAVs2nT0rJM7VWdaUYKdjQt9GQAApTTudWUGcDViYixvd8Y0o142b7Zvv23bzG21Hj3iGjK1d6+jdn6WTApkxwE3RnksidSsZ9+MDPPULU8VLhCuzJgzZw4rWbIk8/PzY/Xr12d//fWXcVuLFi1Ynz59ZOX//PNP1qBBA+bv78/KlCnDPvzwQ5aRkaHrWJ6gmZngNdX4I6dGJzm5MOa8ut5+2/3/B2BsG1ozBrBLKGlc16yZ+9vliUtkpGP7b6w02vjD1n29kc4G4mtWAWfcfh4cWYLwkE3Fe2wq3mPv4gMWiwYsDx7IypQtq71/8eL2H1t82YdGqtudpdWlxb5lIL5mDHLN2eDBjHl7u7ddvXubvnuiZgYuaI9b8QRh5j2QMJPblkwYXH7NemMxO4MKrDzOuv3/unP5A03sPtfDMNvl1yknliicMls5Cp/JVpUv75pjr8HzjAFsEOarbp8+3f3n52lelqG78Ye72yJd+vY1fd+yxendK2PMw6eZnkbS4IJY0h6Ek43QnxqWoC8q4hy+hR15LVxMCJxgla2T/Whg976PwF0obqGIs5rjMfhD7laSE+EL1BA51Qj3UBEWEsm5kcWLTd89cTqLhBkX8BcaAgDOoKKbW0J4IgEqsT3cyUh8jgSEYSw00rc7mZPgQYd+xbM273sPPEveGUQ5tU3u5Fq2++2faCxbb2/0aSWv4Vt8hSFogd26yueiNHhPJN9gEABgDbQzT7sbVzgjOYoHNslz0auRiENp/I7mWKHD7ZHwDDrhV8zDYPTAMnc3JcepDp7Bsip0hFUmnE4yeEz5TLgmD0Bb/IYhmI8q2e6+L+BnAMBzsDFQDUFkU64cz+TtSZAwYwN6L14ZXEQL7EFvfO/aBhFOYxM64g3Mw3JYcCFzEjdgxRUth0kAT9IVD/XYT84mDNxFrhJU0pVbQajgm2GvU9v0JPMSeL6LbpCHeC6KG+5oDvGE4GkOxiTM6CQ1VX8k0gbgUb5KZ+c+sYUQJOAB8uIBciBDIZGjhOMGyuCCxwq5Inibq8nKfu3YY1tWDced3Ry3UwH/AgAi7Xhf2EJh8MRF69EJAFxsu8XwFj5BR2xw4TGeTNqAR1LtirVubollKnqYFQUJMzqxJdx2cdifstUAhrxIRl54SHzvXMaLWIXBmGfzfr2xBDvwDEZglpNbxBCYnYTnJsIRhzJ4AAcyYLqAaGwHAMTAjmRMdnA723j3PMrlyPE8nXMoDwC4hEiH6gnHDdSD9VDOYjory4Wv/+bYg0/wDjZkC06EfsrASaGqXYxI2eMpkDDjAmrgb+uFNCiEXJihzYNYhZcxD2+gDGyL578EffEMdmEWbEg4pYNvMAgpyIMaOObUep1JHfAIhNVygc3Mv9kdf24nAaG4gXDccOLU3g0UwwE08Ih7TUwlErmTjtiA3WhhzKyuhlpAVXdCwoxObLHebonf7T6OL9zkj2knVXEcz+JXdzfDDKFSdzcDwVNgv4uPwGAAgwGzMdzNrXIvwuD4OTvum+PZ+Yx+h44wtR7MXRRGMdxAMdxwuoYkyko+n+exDoBJI+cKTqMSACAeYS47xpPKEvQBAOxEK7e1YQM6oQX2YBH6ua0NtkLCjE5yKJdlruM4quNXPIfayMH45bkQYWQLmGyqnlbq4pC7m+BRRGUbNdd0UKMSlz1NdRH6goCUw3mHjke4BhFLKRHBbm4JUAR2pgl3AyTM6MTX190t8GyCkejuJsi4jwI5fsx+WIhDqIOiuG5ctxstAAB7PFiTsBIvAQB+wXMO1TMLI3APBTAaTkjLq0FQtv2RJ09jtMVWVLViqByARxiO2RiO2cZ1+eGaZEziHvwevWXrM+Aj+z0Gn2IKJrikDQThakiY0YmPj/UyzsAAZrVMXRzEdLyDPHiYAy3Sxl8S/O0OCjulzmK45lCyx7TsJG0idocrWID+OIi6ZkHIFmIA6uAIPsVbxnVqHkJ6rnFOcgFlZZ/2MgKzUQCJmIZxKIB7zmiaGe3BswpG2RAlNQQJaIx9mtsNyHK4XYJKOIWtaIfjsOz6GIlLmI0RmI0RTjt2nmynAW9kytafQRSuooQxJMBaPA8AWIABxjJVcAKf4m1MwAeaz19pXMSnGINiOhwcymbbrIUrhM58SMJZVMBnGK3zX7mWRvgT8/E6CnqQrWJz8BDMYjrQneSmaPYkzOgkJUV/2b8cCNcuMqZa4iDq4x18gimYaPdxnMEgfOPU+gzIwjWUwGVEIshOb65KOI2yOI+bLpyrj8IZ1MVhFMB91e15nO6J5lnCjzV8kYF7KKQp0BxGHbvr3o2WAIAk5NO9z3UUwz40RWsVG5F8SMIlROLr7KirjmJP7BxnEYpbAIB6OChbPwTzURJX8YNCMyNoiFicyLZFAoBAPFIttxdNMQYzdHldaXWCr+E7VMC/GI2ZVuvICf5EE7yObzDDQ4QrwDOCV4YhHmVwAc9gp7ubohsSZnSSmWm9jGAHWtt9nLsoBADI0hHzw903vbQzz4cHDtfngwzjd3sDepXCZUTikqwud9IqW3vTUqLFsUUz0xrbcQeF8SJWObllJppmB6BrhFiMxTSsQ2e0dYKbdu1sLyklx1ATgH3pDG4hxFhHKVzCaHyGfFamZ3yyNRVt8ZvZtlfxI0riKgbhW5vb4izuZD/zjuSsssSr+AGfYgyaKAINlsFFtMVWjMcHuuoplv1M+up4tv5DCQDmBsBeTtSCOZMKOOfuJhhZiP4ATPGA3EECwhCHMkjyALsdvZAwo5O0NP1lr6Ck3cfJghcSEGJ8aash5sB/yoFotZY4hwrG784I+CX16hA5eGxlC9phB6Jt9mbqhuVYja4YqEPb1BixAIDKOKW6XWqvI66V0CjYynSMRSHcwzwMsWt/PYjIv3Eojfo4gM5Yj1IOTPUJHI2bYo3DqIPP8BbmeJB3mKXnVgsxResslb4QJATPYgPGYAZq4SgAUzqDt/EptqIdOsKxZEwtsBvtddYh8tZdVbQRAIJx36Ir8NOCsGVKBXmd2AIJMy5Az1SRFrcQijAkIBw3UQS3MBDfmI08xU2uNODLScrggplBIccUJM5WpPYl9kaj9ct2bbfVIHkluuElrMZ3NkRFVY7mInAFFXAW/5MYdapx24aMzxvREQCwHN1172MrovMLw80cmacXgmZpxNm8b/nsaLnN8QcKZ9s5hGRPr9iDvc9QGOKhNv0nBBNLWb274Ge85KCmrQDu4XOMRK1s7VcJXDVuU6bL6IaVAICZGGVVWOiIDZreUOoxcRh2oxU2oaMs87qw21FOuYoBi1pHfR8FcQmlEYErFtvoSXTEBuzAM7ra/Bx+wXa0RnH8Z7HclxgGwGQf5g7OoCIYDPgQ77qtDbZCwowLKOiA8WMIEnAToYhHGDaiI77B60a1o6upj/04jNporiNOzjK8YhQcANPofitikII8Vh9YNV7LjsniDPK6wTh6J57BFrTTtDkohUuohn/QE0tzuGXmtMBuvIsPZcavrSXz466cwvRHKgD7socL7QIA/IieAIDtiLa4z0WUBqCuHTuKWgCASyiluw19sBjxKIqZGGW2LR7hGIFZZlM3Uhuwn/ECpmCS8bc96QxmYSRG4gscybY/6qBDM+KLDFxCafyGNqrb/0Z1bEJHpGtoiB6qpFiRTplKtaFCa5lP4zkshLvw0Yip1RB/Kda4zmYsGtvQF4vQF4vt2n8DOuEZ7NKVGuIXdEFr7MR8DNZVtzujwFfMHqh18sAYYlqQMKOTRBsG+sUkrrm24oUshOIWQnAL9bMN+V6EPG50TPbcfxMLHhr2sBstURtH8buOKRGlTYswuG2bnVfkFTuyT4ucJIBzbHBsoStWYzm6YYADAlV5nEcZxBndhwFTAMVleAVXUAonUA13bfD8EnU5WzjbjVb4EOPxCpahhYrw2hh/OnyM57Aep1DJLKiiEHxPoorDx9BDWVyEAQyb0cFsWwqCcAh1jMH4tHgJK9ENywEAodkaCDUD8BQEIRaNcBD1AAB58QCzMRzJyIv3NGxTzmd7kcVlC116kD4flXESX0s6yLx4iMmYhFc0hGYtT78a2cEMtbhsg8CnRTjiAQCFcM9oO2WJkriMmwjDBExx+Nhq7EA0lqAvzjsYWdoW7eCz2IihmOvQ8ZyFAVmoghPIbU4GapAwo5OEBOtlBHqDX03DWHyKMbJ1YnTjpePmssWuZAi+Qga8sRzdNMuIkeYX+J/V+pTTQMrf9thLSEd5fjA3UgpECipaiW5qL6vxErphpU3TTFpz2lLXbIEPbLAgl/BWdsyWvlhi1/5a/IfiAPiURG2JtsMRxuBT2e/PMQqVcAa/Ohi/Rop0CkR06FqaMEEgUlBIw4bqFKqgHg5ZjEYchORsUaaHVWPjUriMA2iAbdnaj81oj+HZHdcHKjFcMuBt15Tqb2gLgLtZd8Yvsm0D8S0mYQqW4lWz/a6hmMV6GQwootExC2FriYZX1AOJh5lWVGOpl2EVDZuza9n3JgB8gPEIxS2ZJiu3EYqbaKeYMprrIXZeczEMJ1AN7+fi8ysgYUYntsSZURvpKsmPRIzFxxiDGbKXh1TCFx3OPjSW7bs1+0Vmy8jWAAZvZNnsTfAsfkW0RGMi2KQY5QoNgkiad93KS1MNaZbYJJVkjP+gOs6gkmp7chJxPTajvep2pWusQKQzYDCgvpujAIuOx5l2V1/ojJkipiDsUWGLaaFdaInOWA8AGIz5FvdJQR7cQRE0MJu+AKJwGr+juTFwoBpiWgyATOumhrAREfY8Ta1oT32RYVc6A5GK4BnsNJvWtuYtZ80uSis/nDBQlmqQpILYT+hhfJedQFUAtqUzEHZGUgN6oeFyBlVwArMwAiPxuXHdanTFQ+RBLzsz2QuPvO/wGqTajbo4iPcxEQF4hJsIV9UKugI/pKIB/tKVcBQA3shOyjsRU13ZrByBhBmdBAXpL6tnFC4NbCV1I/5ckujwF3QGYN0mQIsIXEEUTiO/FWPYD/AePsbbZi+xwriNX/EctqEtvBT/6fdsLx2BMMxUjjKDNWKxyGHojwWyNWqdbLnsQFzbsoW53Mx+NERnJxvbPo+1YDBgL5ro3sceuxW9iPD6dxUaRGEToUf76Ew+xHtm6/LiIZrjD9S38PKXehmlwh9dsq9bP6OdBUNXrEZ5nLOa8dhf5XwL+4Sm2Iv22ARfFa2kwBsZ+AjjjFPPBZBo1N4JzqKi5v7FHZgCFzmfJuN92XqRpb4Z9lrVklniBoriPxSXPftXEQEANt3TWpTBRYzAbLycbRAN8AFUHqRgoF2u+QydsAEA8BWGgsHLGP37IOpjIqbiHXysuqctNlqCwriNflhonO5UoyLO4i80wgEb3fzTHHBa8RRImNHJI/ufUZuoJZmimoPhaI3txsRjAuFFYy1vxhWUwmlUxk/ogVfxIwDgJaw2K/cePsLb+BRDske4I7K9caTCjVKjswLdMQ4fGX8nIT/exYfGF3N+JOFdfIj7KIh+WGixnc9gJxbgNYtl9NAw22VatMfTWZcdidUSYspvBV62Wvb5bJfbJjrsXSpld0xb0U51+3d2XI9P8Lbs967sRHmr8aJN9ZTFefyE7qrZn4WWpADuG0fFeg0qRc4bKWJKuJTEGyUIyRiMeUYj9kx4G7elw9fMi+1ZbMBqvIRzFoQIgTKYY3f8ZPw+De9iEzpaVPm/ih8xDtMtHiMFppGXM5PAtlYNoGYwChyAXIulhjQv10WFjdA4TMNwzDHzxnInzfE7PsUY2XUSqCX0fA8fyn6PVVyrXdn2iMrBoB5K4goWYgBmYLTmAFUrkKcWc7I9pz7GOza3x9MgYUYnec0N+Y0MwVf4Fq/ZFBb9MQKM37UM8u6gMC6jlFnCsdLZXg96PBgEzs77UhbnZV45b+JzfIjxxt/V8Y/xtzVLf7W22TPCk468H9gQIdZWHiEQD5BX1snZg56gccIuylK6iLI4jwo2hPfXg96pjyAkIyD7Wr2JWbJt1jo2LdbjOXTHChxBbbNtYmqqFo4Znwtp520JtTguarZZn+BtzMMbxikOS89OM+yxKXFosKKun/CKWRlhA9ML32MPmslcnvUY4Z5BFH5GF/yAV1WnPNfgBQDcZq8Vdho7NHvZKLmPhXG00FAp0xn4SjyYpFpogGeL/hkvoCV2G1MqFM9OnWBtus4SYmpXCOiNVKYblSkgBHVxCGMwQ9VNWi3/WwHcl2mxAxTPQCtJ8Ex7KY7rSEQBVMffFsvlQxI6YoNFTZ81pJr2/EhUHWB4CiTM6MRgwUbvKwzFa1hgvOEPWQjX7pd9c2vFVJEGk5qE93Ee5a3GLRFE4TT2o77VyJEfYZzVuqwZJX6GMaiKk8bfyhf6AdTHw2wh7RhqIgQJqI/9qp2uMsgXYF2YyYckjMAsmQu4sKfYjHayLNXOpCzOIxo7kA8P8TY+we9obnxZCvTaoTgSj0jgg3ScR3mcRZRVe456OIDPMBp5dXiKWdIOFMId3EZhJCEfkpEXScivKshfQUlMxXhjrBzB36hh8dhixCufhmLwQyr+QDMAQKoLc8aI57hotufNTUl8FV+FO/EexQjbGXm3RCiG79EHzbAXQ/GlTfuXRhxewM/ojR+MOZLUuIxS2I1WduUxW2AMF6H+f/UI+lIj2EK4Yzx369EZlxEJA7JkXnV67UC0CLXgcdRYotWV0g+LAAC98YOuY/TEMnyA8UYNjBoi7IatKD1Ih2OOxfKb0AEb0El1etUaJXEZVXEcrbDLuO4cKuAYaqGlZJ0nQcKMTqTpDCrjpKQDMz3MYgS3FTHGdevRyZiQ8BsMRCoCUBFnkAp/RCIOkYiTvUxmYaTxu9C8WJrPl1Ic11AfB43zuALlC/Z1fA0/pGIVXrToinwTYdiFltiFlmYj9S4KD4o8io40DX74Ab0AAHVwBAkIw340NJuK0EMk4nBPMQrqj4WYhTcxCe/DD6myRHFBSHFZ2HSpPUIz7EVz/GFWxp4osFrEZKcV6IJ1OIB6eIg8sgSXUgFGakBt2p6MV/ED5uN1HEADjMZMfCDRoGlRFPHw1ghbbwBDYdw1xhDxRYaq8DkO0zEBH+BZxf0oNB5amim187cC3fAIgcZ7eT8a4NVszWBr7LD6fwBtw1YlwlbtFCqZbTOAGT2VBGLK4F+U01X/VMX5T8me/rqpEMB/z860PglT8Dua25UQs6ciRMJ1yRROCfyHJthrVyj//tmdvJbwJqKgWzIAXpqtlZqMSbiDIkajaYEPMmR5vJoq0jGoURFnUNjK9Lst2BpJHIDVacBw3DR7JvQg3NoFBjCLST+FNsvS8yGmpZRBRq+iJE6iqiyMRFi21k0kwvQ0SJjRyV3JcyZVn0sTy4kHW+pa2AkbsDvbdmBgtuDwFj6FL9IxCe9nd8YmNeDS7EBgAFAmO0Jqe2yRtUV40xTBbZnLqSXjQ6kbZCHcwwAswItYY9EV+WWsRA/8hGewC1kOTqkIpHPmAjUjVKnbeXn8iwKKh02cMx9kIA6lcReFjV4yLbDHYtyHGRhllrW3HxZiD5phFGZYbL+3jg5Fev0tIcLKW0LEl8mHBwjEI+SxUVD7EkPxA3rjdUmaBq00DEomY7LqejUNkLVpqZo4ig/wnq5M71/hjexPUwqHl7EKXmAYoDAUB4Aa2er21zEfDAZNA0m9wSxFWAG1OCgZ8DFqAAVCC5EKf13RnSco4s0IzaR06hmQCwrN8Qe6YQWqW4kFAwAzMAYMBk1BQgi94/Eh9qKZrvtQjWXoIQtiqIcDqG/8/kq2HcokjRgyWfCS2eO0seLFWBoXcQaVcFvHYKIhYs2y3ivJhySjdk6NUMn0nxK9A1BHGICFuIYSmp5Yi7NtLS1FDxfvWaUpgxqHs6d9pdfQkyBhRifpEu2yVNUsFUREMDBrOVYMYGiCfeiHxeiHxbL52psIV705GQw4icoIwCOjgWdtHNVlXKkmmeuJUfMtBmGfTi+CeRgsUT0DP6CX6mi9OK5jhMK2ohqOm5UTnaMXMq3mCRIJ8KRCn1bQvcK4jVH4HKMxE3+jujEK6WL0QwvswecqUV1toRaO4DV8h+L4D/N0GKY2smKs+3O2kfAyiW1FBZzDBExBfiRqTgeKue3uKh37Q+Q1BmqzBzVhxtLUWjUcx1HUxnv4CFMxwTgKtBZcsjTizLKni2NLNWKnszUo87OFn+XogTdUpmbUhExL0yGNEIu/FF4hapqIZOTBcVTFeZQzCjM3EI7hOqeHBcII+TO8hd1ogSqSaVy+/bJu7RJgGklLKWYlgWtfLNK0yxEJMQU9sNwsuGJVnIA3MoznSXm+bAkF8C/Ko6JkWloZlVo8u2PwKb7EG7pCYghWoJtxkKlGIFKsJlm0lMzWmgNCtEoGd3txRYyY/agPBgPG5yaXbfaEkZiYyACwxMREp9a7axdjAF9ewzfGH1XxD/sVHdmfaMjK4RwDGBuBz02FsxeAsT/R0Gw9A1gh3GYAY+Pwoep26ZIGH7N1BXGHnUZFdg1FZcezVhcD2GlUtFrmSwxhQBYDGGuAWNYeG83KtMY23cdkAKuC4wxgrDN+ZgvQT/U/AYytw3MW69mFFqrr62G/YlUWW4JeZsd6FutVds9iz2EdK4lLZtus/a9/UJUVQQL7C/V1nYc0+DBvpLMeWMqK46pZkSkYr7nvYvRm/nikuq0rVrHfEK37eqgt8/C66qYKOGO2cjre1lXnDrRi72MCYwC7ghKqxRriT+OPF7CaAYydQQXNOt/EDNVrUxoXZOtH41Oz3ethP2MAu4hI47r5GKR5rCJIYHPxhmxdZZxgS9CLfYhxLAQ32Th8yP6HWSwOpRw6/8qlGX5nkzHR4XoeIkh1/TFUt7jrZUSYrfwaA83WLUN39gp+NP6Wbm6EfbKyatdNa5HeLwPxNWPgz694r76HqYwBLB6hDGDMD4/ZH2hi3P8CSjMGsKsoblb3LrRg4bhuXLUez5qVmYjJbBtaMwawewhmw/GFZluPoobV/6O1SatMf3ynusM2tDb+rI5jxvWL0IcxgL2FjzWPtRvNGQPYGjyv2objqGJcdwi1GQNYO2wylXMyjvTfLmiOe3GVMLN7t+lCiwdJLKGIl90IH+Mt2fYf8Qp7G9M1b+qpeI+txgs2v5TEMg+vqz4oevY9jYosA15WyxmQabHOyjih+5gMYJVwklXD35rbhSChp64EFDFbpxRmauCo6r5dsJYBjLXDJjYHQ1k3/MS6YpVx+0q8yHpgqXGXsfjIanukLxTpUhcH2K/oKFt3FcXZm5jBGMCSEWi2myUhYRm6s3bYxG4ihJ1Fedm2f1DV7vtJuvgilRXAXfYtBrDm2M0AdWFG7zIOHxqfn5/RWbXYEHxp/LEf9dh8DGLnUUazTi1hZhhms1/QyfhbCDfSpTqOsXMol90hZLESuMK+x6uaxyqBK2aDjmew3XjO/fCYtcdG1hy7VTt/tcXSf5MuzfA764uFTrmuWovWpjo4aFM9WsKM8t0JWBYepYtUmFHbPhGTGYNJmJG2QbrEooHmuQ/DDc36HXlHqy3PYR17iCA2Ae8zMVhUHlu6S0vsVK3nf5hl/Cl9d6mdN+Ui/SEGmNL1x1GFVcYJWR8zA2+ayjkZEmYkuEqY+e8/7QfyZ3RmjbCPBSKZGZBpdsfsQCunPgR6ljDc0F32bUxnBXGHpcJXs0wMNrM22Kq5fRQ+Y1vQVvcxq+If1hG/am4vj7NmD5vWokeYESNwteUegmW/Z2OYWZlW2MGCcU93m9QWgLFNaCdb9wHelZ03IIuFIp75II2NxEyL9V1CSZffR0WQIPvdGT+zwfjK7vqOooax0xHCTFX8w5pij7HYBLxvU51i5GmtXG0cYt9igEzjtAdN2R0UZPvQyFjOmnCh1GaK6/QPqlq8zxxdJmMia4FdLr3eDxFk1BRLlz1oalM9WsLMHRSUlQMY64cFFgVI6aLUtmktX2C45vOxBs9r7lcDR1Xr34o2qhodtUWvcJYJg/F7PELZTIw0O7ZUyNEakP2AniwMN9gLWK26/SZCNJsh/bEbzc0GpSdQmT2Gn9m5Ne7vZEiYkeAOYUYsv6AT64ANsnXOUAvnxHIBpdkj+OfoMZOQV3NbZZxgh1FLVz1CmNmMGOO6bviJ+eMRq4+/mAGZ7GUs190uMQ2iXL7GQLMXgC3LLRQ2W6cUZsQL7i4KuP2eYICqQPUAeZxSdzICWQw2G38L9fU3eM2meq6iOFuM3lbL3Ud+4/c8eODQtdRalBoyZy/dsczl17wCzpittrWOqvhH1mYvZDDANK0hFiCL+SKVBSJZd91BeGhze46jCmPggujrmKdZ7jdEs9K4YLZ+BV5y+nm+iEizdcG4J/udDm8WiGQGMLYdz9h1nCOoyRogljXGXvY9XmVfYTBjAPsXZVXLl8M5i/UNxlem+8LJkDAjISeEGalETYtrFjE3bcuyF42N3/9EQ6PNiJ6pIemiZhMklm8xwKn/U69tjbuWrWiTo8cDcub52omWzBepbj+/nrhcQQnmh8ey1bbWobSNYeDTfs5o3xuY69D+0veE1rIUPWS/a+NQjpz7AfhWdX1O3qutsMPidk+1mSFvJp3cvg0sRzesxEs5nlPmaSRaZ+wQwJSgrqQkJP1pVEKbbI+BaXjXae16TcU12BEa5IALpyO0zeGknsrM266iFXajh0qIegKIwH/GgGztscmY2NYW/lTxgpyTnZrDUb50MGKxnuji+xVebIdR16Fj6kUrVMaLKmloXIUy5ow6ntcHkjCjk7zp97JFGeffVHvRxGlJB5WupE8DIdlBsiIk0YAdyc2kzIVF5Byf4u0cGyzojbfzNCLCIWxCxxwXaF1NbR2xcdRSFbiTZZL4Y67GWoyczegABi/EKOKfuRsDY8zzRCwHSEpKQnBwMBITE5E/v/OSDcYdvovSdbXz4zhKaVxEHMq4rH6CIAi97Ed9vIRVuGJHdmfiKcLJ4oMj/TdpZnSS6ePv0vrXoYtL6ycIgtBLAxwgQYawyI85qC3SAwkzOrmX6NpTVUNHmHKCIAiCIMwhYUYn6enWyxAEQRDE00AzlSS77iRHhJkvv/wSkZGRCAgIQIMGDXDggD4PjuXLl8NgMKBLly6ubaAeslyThZkgCIIgchulJN6jnoDLhZkVK1Zg1KhRmDRpEo4cOYIaNWogJiYGCQnaGUcB4NKlSxgzZgyaNWvm6ibqgnnrT5BGEARBEETO4XJhZubMmRg4cCD69euHypUrY/78+QgKCsLChQs198nMzETPnj3x/vvvo0wZz/DwiYx0dwsIgiAIglDDpcJMWloaDh8+jOjoaNMBvbwQHR2N2NhYzf2mTJmC0NBQDBgwwOoxUlNTkZSUJFtcgcHgkmoJgiAIgnAQlwozt2/fRmZmJsLCwmTrw8LCEB8fr7rP3r17sWDBAnz77be6jjFt2jQEBwcbl4iICIfbrYbhsfWokQRBEARB5Dwe5c304MED9OrVC99++y2KFCmia59x48YhMTHRuFy9etUlbbt/3yXVEgRBEAThIC61ai1SpAi8vb1x8+ZN2fqbN28iPDzcrPyFCxdw6dIldOrUybguK9uLyMfHB2fPnkXZsmVl+/j7+8Pf37UB7QAgCCkuPwZBEARBELbjUs2Mn58f6tSpgx07TEkDs7KysGPHDjRq1MisfFRUFI4fP45jx44Zl+eeew6tWrXCsWPHXDaFpAffhGtuOzZBEARBENq43N941KhR6NOnD+rWrYv69etj1qxZSE5ORr9+/QAAvXv3RvHixTFt2jQEBASgatWqsv0LFCgAAGbrc5osL3LNJgiCIAhPxOU9dLdu3XDr1i1MnDgR8fHxqFmzJrZs2WI0Cr5y5Qq8vDzKdEeVe95FUMLdjSAIgiAIwgzKmq2TI79cRe0uJZ1WH0EQBEHkaihrNkEQBEEQhHMgYUYnzNfP3U0gCIIgCEIFEmZ0UiycEk0SBEEQhCdCwoxOcoGNMkEQBEE8lVAXrROvxHvubgJBEARBECqQMKOT5IRkdzeBIAiCIAgVSJjRia+vu1tAEARBEIQaJMzoxNvb3S0gCIIgCEINEmZ0kkXOTARBEAThkZAwo5P7AeZZvgmCIAiCcD8kzOgkNc3g7iYQBEEQBKECCTN6MZAwQxAEQRCeCAkzOmE+5M5EEARBEJ4ICTM6CS+c7u4mEARBEAShAgkzOvH2cm6qc4IgCIIgnAMJMzrxSrrv7iYQBEEQBKECCTM6eXz7obubQBAEQRCECiTM6MTHm6aZCIIgCMITIWFGJz4+7m4BQRAEQRBqkDCjE0aKGYIgCILwSEiY0cmxhGLubgJBEARBECqQMKOTGwmUNpsgCIIgPBESZnRy7z6lMyAIgiAIT4SEGZ1kMNLMEARBEIQnQsKMTgK9Ut3dBIIgCIIgVCBhRieUzoAgCIIgPBMSZnQSkJro7iYQBEEQBKECCTM68Up+4O4mEARBEAShAgkzOqF0BgRBEAThmZAwoxMvOlMEQRAE4ZFQF00QBEEQRK6GhBmd3AmKcHcTCIIgCIJQgYQZnaRlUdpsgiAIgvBESJjRiX8aeTMRBEEQhCdCwoxOAtMozgxBEARBeCIkzOgkNPWqu5tAEARBEIQKJMzoxEBniiAIgiA8EuqideKbnuLuJhAEQRAEoUKOCDNffvklIiMjERAQgAYNGuDAgQOaZb/99ls0a9YMBQsWRMGCBREdHW2xfE5heETCDEEQBEF4Ii4XZlasWIFRo0Zh0qRJOHLkCGrUqIGYmBgkJCSolt+9ezd69OiBXbt2ITY2FhEREWjbti2uXbvm6qZaxNvb4NbjEwRBEAShjoEx5tKkQw0aNEC9evUwd+5cAEBWVhYiIiIwfPhwjB071ur+mZmZKFiwIObOnYvevXubbU9NTUVqaqrxd1JSEiIiIpCYmIj8+fM77X/s7vE1Wi4f7LT6CIIgCCJX42TxISkpCcHBwXb13y7VzKSlpeHw4cOIjo42HdDLC9HR0YiNjdVVR0pKCtLT01GoUCHV7dOmTUNwcLBxiYhwTaReZiDNDEEQBEF4Ii4VZm7fvo3MzEyEhYXJ1oeFhSE+Pl5XHe+88w6KFSsmE4ikjBs3DomJicbl6lXXuFDfLlTBJfUSBEEQBOEYHh2jf/r06Vi+fDl2796NgIAA1TL+/v7w9/d3eVseeeV1+TEIgiAIgrAdlwozRYoUgbe3N27evClbf/PmTYSHh1vc97PPPsP06dOxfft2VK9e3ZXN1AXNMhEEQRCEZ+LSaSY/Pz/UqVMHO3bsMK7LysrCjh070KhRI839PvnkE0ydOhVbtmxB3bp1XdlE3TzKU9jdTSAIgiAIQgWXTzONGjUKffr0Qd26dVG/fn3MmjULycnJ6NevHwCgd+/eKF68OKZNmwYA+PjjjzFx4kQsW7YMkZGRRtuavHnzIm9e9031+OdXn+YiCIIgCMK9uFyY6datG27duoWJEyciPj4eNWvWxJYtW4xGwVeuXIGXl0lBNG/ePKSlpeHFF1+U1TNp0iRMnjzZ1c3VxNvbbYcmCIIgCMICLo8zk9M44qduiRUf/ItuE8ijiSAIgiAAPD1xZp4kvFIeuLsJBEEQBEGoQMKMTmiaiSAIgiA8ExJmdOJDwgxBEARBeCQkzBAEQRAEkashYUYnj1Mpah5BEARBeCIkzOhEkpibIAiCIAgPgoQZvZBihiAIgiA8EhJmdJLoTekMCIIgCMITIWFGJ0mprs/MTRAEQRCE7ZAwoxMvOlMEQRAE4ZFQF62TQoEp7m4CQRAEQRAqkDCjk4I3z7q7CQRBEARBqEDCjE58Mx+5uwkEQRAEQahAwoxOAgPJN5sgCIIgPBESZnSSkeHuFhAEQRAEoQYJMzpJzyTNDEEQBEF4IiTM6CQpmU4VQRAEQXgi1EPrhDHSzBAEQRCEJ0LCjE7yez10dxMIgiAIglCBhBmdZPkGuLsJBEEQBEGoQMKMTgx0pgiCIAjCI6EuWid5vSidAUEQBEF4IiTM6CTv/f/c3QSCIAiCIFQgYUYnBi/yZiIIgiAIT4SEGZ34B9CpIgiCIAhPhHponWR6+bi7CQRBEARBqEDCjE6S84S6uwkEQRAEQahAwoxeDGQzQxAEQRCeCAkzOvHyJmGGIAiCIDwREmZ0Qt5MBEEQBOGZkDCjE6/g/O5uAkEQBEEQKpAwo5N8mffd3QSCIAiCIFQgYUYn+R/ddHcTCIIgCIJQgYQZnQTcj3d3EwiCIAiCUIGEGZ0YyJuJIAiCIDwSEmZ0kpbu7hYQBEEQBKEGCTM6SfMOcncTCIIgCIJQIUeEmS+//BKRkZEICAhAgwYNcODAAYvlV61ahaioKAQEBKBatWrYtGlTTjTTIo+KlXV3EwiCIAiCUMHlwsyKFSswatQoTJo0CUeOHEGNGjUQExODhIQE1fJ//vknevTogQEDBuDo0aPo0qULunTpghMnTri6qZahdAYEQRAE4ZEYGGPMlQdo0KAB6tWrh7lz5wIAsrKyEBERgeHDh2Ps2LFm5bt164bk5GRs2LDBuK5hw4aoWbMm5s+fb1Y+NTUVqampxt9JSUmIiIhAYmIi8ud3XqC7w3P/RJ3hTZxWH0EQBEHkapwsPiQlJSE4ONiu/tulmpm0tDQcPnwY0dHRpgN6eSE6OhqxsbGq+8TGxsrKA0BMTIxm+WnTpiE4ONi4REREOO8PSPDNfOSSegmCIAiCcAyXCjO3b99GZmYmwsLCZOvDwsIQH68etyU+Pt6m8uPGjUNiYqJxuXr1qnMar4AZfFxSL0EQBEEQjpHre2h/f3/4+/u7/Dg+SXddfgyCIAiCIGzHpZqZIkWKwNvbGzdvylMB3Lx5E+Hh4ar7hIeH21Q+pyiYrm6wTBAEQRCEe3GpMOPn54c6depgx44dxnVZWVnYsWMHGjVqpLpPo0aNZOUBYNu2bZrlc4rQPMluPT5BEARBEOq4fJpp1KhR6NOnD+rWrYv69etj1qxZSE5ORr9+/QAAvXv3RvHixTFt2jQAwIgRI9CiRQvMmDEDHTt2xPLly3Ho0CF88803rm6qZcgzmyAIgiA8EpcLM926dcOtW7cwceJExMfHo2bNmtiyZYvRyPfKlSvw8jIpiBo3boxly5Zh/PjxePfdd1G+fHmsW7cOVatWdXVTLZKa+gQYGBEEQRDEE4jL48zkNI74qVvi9terUWTwS06rjyAIgiByNU9LnJkniYxK1d3dBIIgCIIgVCBhhiAIgiCIXA0JMzrJKOqayMIEQRAEQTgGCTM6CUihoHkEQRAE4YmQMKMTw2PKzUQQBEEQnggJMzox3L/n7iYQBEEQBKECCTM6CUq+5e4mEARBEAShAgkzOvH2dncLCIIgCIJQg4QZgiAIgiByNSTM6CQ11d0tIAiCIAhCDRJmdPI4lTJNEgRBEIQnQsKMTjIjy7q7CQRBEARBqEDCDEEQBEEQuRoSZnSSGV7c3U0gCIIgCEIFEmZ04v840d1NIAiCIAhCBRJmdGJISXZ3EwiCIAiCUIGEGZ0YkkgzQxAEQRCeCAkzOgl8kODuJhAEQRAEoQIJMzqhdAYEQRAE4ZmQMEMQBEEQRK6GhBmdUDoDgiAIgvBMSJjRCQkzBEEQBOGZkDCjk4zIcu5uAkEQBEEQKpAwoxcDJZokCIIgCE+EhBmdZIUVdXcTCIIgCIJQgYQZnfgVyuvuJhAEQRAEoQIJMzbwJxq5uwkEQeQSMkDBqQjHGYSv3d0EVcbgU3c3QQYJMzaQDl+X1r8OnfEY/i49BkHYyilUsrj9NXybQy3JXfgg091NIJ4AvsUgdzdBlRkY4+4myCBhRicBAcBR1MJdFHTZMbphBUrhssvqJ1zDSVR2Wl3b0dppdVmiNbbrLlsfB2AAw0WUVt3eBPuc1SyCeKJJs3FA/Aa+dFFLnjxImNGJjw9wG0VwA64zBE6DP4KQYvwdiTg0xR8O1dkVq3WVu4cC8EWaQ8cCgOl4B4Vwx+4puThEYirGO9wOe6iOv+3abyom4CZCLZaZhMm6ph1643u72mArO9Eab+NjXWWTwe3FFqK/6vbW2OG0dukhDb54AWty9JiuRjpIKoQ7qmU8SWu7BL2dWt8+NHZqfZ7ALrQ0fp+HwQAAP6TbVAeDa7xotyHaJfW6ExJmbCAa21EFp4y/TyNK134/owtG4zOz9evQGbMxXLauGK4bvychP+6jgPH3CVTRPEY7bIYv0mAAw+9oblx/DDWxGl2ttnE9nkOGYtRwB4Ws7qdkLD7GCVTFA+SzeV8AmI3/YSKmWi33HQYYvw/EN9iJVsbfmfDCT+hu/H0LRYzfLb00j6O68fvnGKm3yaiE0wjHTXgjwyh8/oUGsjIf4x20wxaL9XyEcarrH0Cf8fmP6Gm2bhVe1Cy/Be101Wtqh/o1LYmrst/HURVf4g2sxfM21a+XuRiG0xamvg6iruY26bNwBRE4j7LwQTp6Y4muYysHBwPxDQDgDCqiEf60uO9vaIOF6Ke6bSM6Gr9nwEe1TCQu6WqjkmGYg71oIlunnDpMQAgAYBZG6Kqzj0LorogzaIHdCMZ9m9rWGPtgAENxXLNadiymGb+fR1nj9/GYilK4hJH43KZjK6kkebc7gxew1vh9CObr3k96jxTBbbPt1fCP7rqk7z4pq/GimZZoLoaiPTahLg6alY/GNqxHJ+PvReiruw05BnvCSExMZABYYmKik+tlbBdaMAYYl5V4UfZbaxmCLxnAZOvOoRwLwkP2BYYb1wGM1cJh2e8IXDb+3oAOqvVH4qJs1ZcYIqvDG+mabXsV37OdaMnG4iNZGxegn1mbLS0L0I91xs/G31vRRrXccHzB/kFVzXpGYqbqcWPRQPb7NXxj9h93oiWbgTcZwJgXMozbi+Iaa47drCN+ZYVxi3XBWtVjA4wVwF1WAWfYTrSUbbuK4pptToe3bJUvUhmQxYoggZVCHCuKawzIYj2w1OI5LIIEVhTXjL9/QE/GAJaEvLJyd1BQdf+iuMbOoAI7iUpsJGaybviJ9cd3sjLxCGUN8afx3lqCXmw3mmu26TH8jD//h1m67wfxVU9Z5bVVLj+hG/sL9dknGMOWoTvLj/ssCqc0yz+PNexPNGSlcYEZkMmaYo9xWxROsUAkszx4wLyQwbyQwQDGGmOvrI6P8ZZq3b2xWPa7Jo6w7/Eqm4yJZv93F1qwtzFddk76YqFqvavQ1fg9EMmq5QDGumOZ7mswBp/I7skzqMAew49tQjvWC0vYZEyU1e2LVFYECVbr/RwjZL9T4SsrMgqfMQaw/ahnta4ApDCAsU8x2mrZTvhF9tsPj1kIbjIgy7j6XXxgsY5jqK65rQzOW23D36gm+/0I/uwiIs3KLUEvFo7rZus3I4a1wC7WARs0jzEDbxq/l8dZs/vKgEx2AaWNvxviT9n2syhv/K58176CH1kPLGVeyGB58EDWxkbYZywq3acCzjCAsel4W3K/8HPubBzpv13QHPfiKmHm+nVmdtMVwF32Piaw9tjIemMxO4HK7F+UZQFIYY2wz1huFv7HAMbexAzjumsoygDGyuMsY+CCEcBYTRyRvWCkN5aaMPMFhps9D89hHWMA+xMNjeuUNzwD2AlUNttXfOmJH8xuagaww6il+gDuQgvWC0usvgzUHhaxfIf+xo72BsJk26TCCwNYXiSxayjKfsQrmofri4VsGGabrVcTZt7EDNmqg6hj/FEP+7O/Zln9X5YWH6Sx9XiWvYWPVTslgLFKOGn8XQXHjd+lgvNcvMGq4W9ZZyR9EUmXbzFAtuItfGxWRipAM4BdR7jx+060NG6SCsnS5RJKyn7XxQGz6/w7mlk/QdnLWZRnI/A5Y+CCTiCSzYpJz5Oea+GHx9lCpfpu1fA3YwB7iCDmgzRWFv+qFnwH04zf96OeWRFlO7yQwX5GZ/Y+JjCAsYXoq1rvfAxio/AZG44vVOsS9dXAUc3/fQQ1ZduHYo7FUy0670TkM66LxEWL12Y5XmYZ8JKtS0agrJgQZnaglcW6umKV8acBmWYCZSp8Zb+l71St61wV/1g8ZiwasFn4H3uAPGbbpMLMAHxrHMDMxEjGAPYyljOAyQSiDzGOAYyVxCWWggBZ20rgiqz+kZjJDMhkAGN1cFCzjUKYmYZ3LN5XmTAwBrB8SGRN8Ae7iEjWARvYGHxiLFsBZ4zfLyJS9ZDiSxEkmK07hNrGdW2xhR1EHTYPr5vKORkSZiTklDDTHhstvigAxubiDfYYfqw6jmnelADLfllnmT2Myn3UOhMfpJkdV02Y4UsWa4OtxhV70dhs3xK4wrpgrfGhk450BuMrmcZCqjHYhtZ2CzPioQzGPePq9zFB9n9DcJNtxzOyekQbbV1exErjj/GYwgrijlmZRehj1maAsWXozhhg7GzVyuhdvJAhG4UVwF1mQCbbiPbsawxk0fjNuE2qaVqPZ82uq9YxpJo/Bj5SU5ZpiZ2yFSVxyfhdjMoA3vmdQzlZ2aXowUrgCnsJKxgD2HY8I6v7VXzPxuAT9jUGMgawWyjMGMDuogC7hqJsOL4waqAYwCritK5zJ23jQdQxXlPze17vksUMyDTeU6GIN26UCtKlEGfxulu7J6Sanfcxgb2PCewGwlhxXDUrWxcH2FHUYAxg4/AhA8yFGamm4AhqytrQB4ss/mfpAEes0yPMSH9fRzhrij2yYkKY2YOmFutSW50PiewNzGXhuM5OoLJxQyYMsvZ2wVrNqqUDQgawD/AuG4mZjIG/pwBmvF8ZuIBaCSdZPiQa13khwyik18FB2XtWCDPL8TIrhv+M65XaJaUwMx5TjD/bYovmeTmPMowB7DiqWLyvApGs+u4CGCuE22b7LkRf1bLFcVX2nAOMlUIcm463Zf9PbXE2JMxIyAlhZgLet3iB5Yu8o/kDTRgD2GVEaJb/BZ3Y1xhoXCembF7Bj2Y7qAkzQXjISuOC6o04Fh8Zf8Rgs67/IB6uQZjPjqAmYwAbi49knW0B3JWpTttjo1lF0fjN7AH7FgNYHjyQjQrEIp0ey4dEFoSHLAabWWPsteH8my9L0EvyYlAXBArgLvsCw2VaBoALIFE4xYAsdg1FGYO6gKB3aYUdxh91cFC2zR+P2H8oZnwBiw3mwoz2Uhi3ZOp+6QtSes99iwFsMXqzetjPCuCu7LoqyxdBAnsJK7Kn0+THEtM2yqUL1rLrCGcj8DmbjInZmj9+7vMiiQ3E1ywU8br/V37cN/6YgvEM4NoaPzx26N4Qi1SYEb+FoDUfg2TbpIv0h1q9QpjZiPay82+pLdLzLBVmdqCVTJswEZNlbaiBoxbrDcY9xgB2A2HGddJpB6V2lIFPk4jvKQhQbbvQPl1BCfYrOso2Sn9buwZv4WPGwKfgApHM2mGT7n2V1+E79Jf9HoivVeuqhcOsKv6R1dEJv8jKCGGmNbbJ1iuFmTDckP3WI8w8hh+7jUKMgU9ti03KaXVbFvFFS5hxZHE2JMxIcKUwUxuH2AS8z/zxyO6LH47r7COMNbNzsbTkQyIriDvMD49lG2rhMLP2IlQuUmFG7z61cJi9jwksEMksACmsCo4zgMlsQACuKfkcI1hvLDbuKx2JyuvNYoVxy2r7q+A4q4kjTn0A5cKM/fWUxb9sDoaykrjk2Ash+8tLWGG2zRvpxnN0BSUYA1hfLLT7GOrCDJ8CK4TbLBj3WBAeGjeoTfHYv9h2r1pb1qILYwAbiK+dWi8g79SV25rhd8YAdgpRZtuEALAbzVXrVRdm9C/BuMcWozfbgVbZ94Z5mQo4Ixs4WFryIVEmLEkF2SA8ZF7IkL0zFqEPa4o97ADqSqZf5UsRJLCZGMkq4wQDGHsW6xkD2FHUYN5IZxvRnk3CJKttEzYdQmMrNB3SqQ+tpQ22susIZ+2wiQH8PZIGH/YB3mUAM9qmqU21i0V8eR3zVNeLqUOx9MMCWQVSTQ8DsgdB/Gch3GYM3N5uDZ43CjCP4ccq4SRbih4ybUkAUthB1JFNPeld6uIAa41t2fZFzn1OnA0JMxJcJczcuePcm8Dum0fyw579n8cah/aXLl7IYHMw1DiXrLYYkMmG4wtWG4fcfu7EUgbnWTIC2ScY4/a2SK+pmjAjXQriDnsG2+2aXhuJmewR/FkDxKpub4FdjAHsJCoxL2SwptjDmmKPpqbFExZXCjPChoZB/Tkph3Oqg5pAJLMW2KUpaPyGaIv1unuRCjPK/8CnwuwTSCvjhNHY15ElP+7bcE/K26r8P8G4p3mdAMY2oANLha9sygYwPa+v4RvZemEfJVZIhRm1AU9h3DIOFsrhnEffF1qLs/FYYebOnTvslVdeYfny5WPBwcGsf//+7MGDBxbLDxs2jFWoUIEFBASwiIgINnz4cHb//n3dx3xahJml6GFnHVlsBD5nTfCH2/+LOxdP6qTFF2vCjCv/s3QK093nQ+9SCLdZMfzHgvDQ6XVLDYCdWe9qvODR51nqzaQ2hf10LVmq05bNsZtNwiTV5ykPHjAG7nEoFWasT39msSXoZdQc5ZbF2TjSf6sHNHASPXv2xI0bN7Bt2zakp6ejX79+GDRoEJYtW6Za/vr167h+/To+++wzVK5cGZcvX8bgwYNx/fp1rF6tL/jbk04obqIdtmAVXrKzBgO+sCGGypNKlgflzdmDZmiA/diKGJcex9J/Lo9/XXpsV3AXhV1W9wWUw3S8g7t2xFqyxAh8gXDEY44ivpSn4C1JweCFLDe2xBMwIE0lUOEetMAetFDdIxl5kQ9JSIMfAvFIUhOzeixl7B7CRpwvW3FOnTrFALCDBw8a123evJkZDAZ27do13fWsXLmS+fn5sfT0dF3lXaWZefjQ/VIwLU/qoj4CzMllEiYZf7j/fNDizmUEPmeDMN/t7XgSls74mXXEr25vh6sWZ+ORmpnY2FgUKFAAdeuaonFGR0fDy8sL+/fvx/PP64sOmpiYiPz588PHR72pqampSE1NNf5OSkpyrOEaaByeIJyA+ggwJ4nTyLtEPH2Q5tZ5/IIu7m7CU4PLuuj4+HiEhsrz1fj4+KBQoUKIj4/XVcft27cxdepUDBqknTV02rRpeP/99x1qK0E87fyIV1EO57FHkgqDIAgit2BzbqaxY8fCYDBYXM6cOeNww5KSktCxY0dUrlwZkydP1iw3btw4JCYmGperV69qlnWENMdzMBKEx5IFb0zEVGxHG3c3hSAIwmZs1syMHj0affv2tVimTJkyCA8PR0JCgmx9RkYG7t69i/DwcIv7P3jwAO3atUO+fPnw888/w9dXO226v78//P1dr6JPTnb5IQiCIAiCsAObhZmQkBCEhIRYLdeoUSPcv38fhw8fRp06dQAAO3fuRFZWFho0aKC5X1JSEmJiYuDv74/169cjICDA1iYSBEEQBPEUYfM0k14qVaqEdu3aYeDAgThw4AD27duHYcOGoXv37ihWrBgA4Nq1a4iKisKBAwcAcEGmbdu2SE5OxoIFC5CUlIT4+HjEx8cjMzPT0uEIgiAIgnhKcamPztKlSzFs2DC0bt0aXl5e6Nq1K2bPnm3cnp6ejrNnzyIlJQUAcOTIEezfvx8AUK5cOVldcXFxiIyMdGVzCYIgCILIhRgYY8zdjXAmSUlJCA4ONrp0O4u7d4HCrovRRRAEQRC5CmdLD4703y6bZnrSMBjc3QKCIAiCINQgYYYgCIIgiFwNCTM6seAdThAEQRCEGyFhRieUzoAgCIIgPBMSZgiCIAiCyNWQMKOT9HR3t4AgCIIgCDVImNFJdigcgiAIgiA8DBJmCIIgCILI1ZAwQxAEQRBEroaEGYIgCIIgcjUkzOjE39/dLSAIgiAIQg0SZnRC6QwIgiAIwjMhYYYgCIIgiFwNCTM68fZ2dwsIgiAIglCDhBmdUDoDgiAIgvBMSJghCIIgCCJXQ8KMTjIy3N0CgiAIgiDUIGFGJ5TOgCAIgiA8ExJmCIIgCILI1ZAwQxAEQRBEroaEGYIgCIIgcjUkzOiE0hkQBEEQhGdCwoxOKJ0BQRAEQXgmJMwQBEEQBJGrIWFGJ5TOgCAIgiA8ExJmdELCDEEQBEF4JiTMEARBEASRqyFhRieZme5uAUEQBEEQapAwoxNKZ0AQBEEQngkJMwRBEARB5GpImCEIgiAIIldDwgxBEARBELkaEmZ04ufn7hYQBEEQBKEGCTM68aIzRRAEQRAeCXXRBEEQBEHkakiY0QlpZgiCIAjCM6EuWickzBAEQRCEZ+LSLvru3bvo2bMn8ufPjwIFCmDAgAF4+PChrn0ZY2jfvj0MBgPWrVvnymYSBEEQBJGLcakw07NnT5w8eRLbtm3Dhg0bsGfPHgwaNEjXvrNmzYLBYHBl82yC0hkQBEEQhGfi46qKT58+jS1btuDgwYOoW7cuAGDOnDno0KEDPvvsMxQrVkxz32PHjmHGjBk4dOgQihYt6qom2sSjR+5uAUEQBEEQarhMMxMbG4sCBQoYBRkAiI6OhpeXF/bv36+5X0pKCl555RV8+eWXCA8Pt3qc1NRUJCUlyRaCIAiCIJ4eXCbMxMfHIzQ0VLbOx8cHhQoVQnx8vOZ+b775Jho3bozOnTvrOs60adMQHBxsXCIiIhxqN0EQBEEQuQubhZmxY8fCYDBYXM6cOWNXY9avX4+dO3di1qxZuvcZN24cEhMTjcvVq1ftOjZBEARBELkTm21mRo8ejb59+1osU6ZMGYSHhyMhIUG2PiMjA3fv3tWcPtq5cycuXLiAAgUKyNZ37doVzZo1w+7du8328ff3h7+/vy1/wS5y4BAEQRAEQdiBzcJMSEgIQkJCrJZr1KgR7t+/j8OHD6NOnToAuLCSlZWFBg0aqO4zduxYvPbaa7J11apVw+eff45OnTrZ2lSnQnFmCIIgCMIzcZk3U6VKldCuXTsMHDgQ8+fPR3p6OoYNG4bu3bsbPZmuXbuG1q1b4/vvv0f9+vURHh6uqrUpWbIkSpcu7aqmEgRBEASRi3GpvmHp0qWIiopC69at0aFDBzRt2hTffPONcXt6ejrOnj2LlJQUVzbDKXhQyBuCIAiCICQYGGPM3Y1wJklJSQgODkZiYiLy58/vtHofPQKCgpxWHUEQBEHkapwtPTjSf5MlCEEQBEEQNvHOO+5ugRwSZnSSleXuFhAEQRAEoQYJMzp5/NjdLSAIgiAIz2DTJne3QA4JMwRBELmQZ55x37H37dPeFh4OBAbmXFsI93D8uLtbIIeEGYIgiFyIRriuHOHwYe1ttWpRYt4nnbAwYOtWd7dCDnkz6eTOHaBIEadVRxAEkSupXRvIzAT+/tvdLSEcpWZN4Ngx2/fLynJNuBLyZsoB/Pzc3QKCIAj307gxkJTk7lY82bz5JjBjhuuPExdn+z4VKnhm3DUSZnTi7W37PmFh5uvu3QOefdbx9jwpfPSRu1vgGFWrursFjvPDD+5uAeEsChZ0dwvUWbjQOfXkRAevRk6/s19/nWu/XE1iou37+Po6vx3OgIQZF1KokPr6n38Gxo0DWrbkvwcMyLEm2UzFivrKVahgX/1nzgDBwfbtW7OmffsRJho21Ges2bu3a9uxebNr68+N2JPc9t4957dDycmTQJcutu2j9z2iZOhQ+e/QUPvqcZScNjEoVMhz32+VK7u7BeqQMKMTHzuyWFWvDgwfLl+XlAR8+CGwbBnQti3w8CHw5ZfyMu++a7neVq1sb4u9nD+vr9y4cfbVv2WL/R1lToxcAJ5kNDYWUEsWf+JEzrTBVZQsCdy4Yb3cunXOP3apUqbvlSsDu3c7/xi5mYkT3d0CdbKybNeoVqlieXt2LmIzpkyR/5beMznBxx/n7PFymrZtbd/n99+d3w5nQMKMTmyxmZk1C9i7lz8Ib78t3xYZCUyeDFy+zEdRefLwEZh07tLaA1uzJvDtt9rbGzfW31Yl2TlAjagJDMr6f/kFyMiwXO8HH6iv79BBf9sEzz8PvPCCdQHzww95OTVsmR66eJFrMBYt0r+PFp422nr5ZaBsWfm6PHnMy7nCRuLUKdP3gACgeHHnHyM3ExXl7haoU6UKv14dO+rfJzhY+x363nva3lHKfXJaMyOi3K5cmXPHrFiRa4JywjWnWjXb91EOvj0FEmZs4PJlPkVkjTJlgCZNuFBy+7Z8m/QG/fRT0/fISL6NMaBwYcv1d+8OPPec+rZixVx/s+3bJx9JFS0K5M1rX11VqlgXhJSsXQusWQMcPWq53Msv83Jq2KJRsbV9ltCaenQXjRqZr/Ny8K1QqZK+cvv3m74HBAAPHjh2XD18/LH5aN9VlCjh2P6eapsgsOR+/eKL5uvS0tTLTp6sXY9yqu3QIavNwqRJ1svYij1Tfmo0a2a+Tpnz7+xZrrHfts05x3Q2atfWEyBhxgZKltQ3Vyx9mOyJt3DypPa2d94B6tdX31a4MHDtmmOjf72CkHJUZq/NDADMm2f/vko6dQLatOExOMqU0b9fvXra2xISHG+XIDLSeXU5SvHiXPiVal26dDEJFW3a2FfvzZv6yh05Iv9dq5Z85C20hM40sn7nHcenbw4eBP79F6hb17ROTV3/33+OHcdSLBe9WBsYAUDr1tbLSL1XYmP5pyXhc9Uq63UKfHy0NR8pKfLferQV77/Pp/jtQUuDrEeI0sOSJXzwJ2jVSn1gmp7unOOpsXcvnz3Yvdt0LZ8ESJhxkKJFgXbt5J25VGOg5tFkjdOntbdZ6gzv3LH9WFIuXNBv2Ce1c9GjuVi8WH39+fPAnj3ydcOH297hiFHwyy/zYE6xseoahkGDtOvQmuaQqmKVmhU1WwDpPPsbb8i36TF0fe8962UsoVezcu0aFyik0Vw/+cT0/coVx9phiTZtgA0bTL/FdObXX/NPqcbIlnATNWvqt/OyRESE9rayZYFy5biGVKBnatfWqLiW7lWAd+wXLlguM3w4F8YtvYf69eNaZ2vHEoj3m5Y2duNGy3VJz5UY5b/0kvZxRaTjTp2ApUvl27Wm5O2Zvga4RkRJhQq2DYws4e0tt1HbtQtYvty8nN5p3bg4YO5cPhDQS5MmwIgRQIsWzhPSPAESZuxAzON++ilw/brlDkqpKrbXoKxzZ/lva14LotMdPVr/MYRAIF6i/fsDr76qXlZqZ3H1quV6u3eXj2KlrF3LVa9S7Uy5ckBysr42C8QouFcvPtrR2l90lkoOHlRf36GD/KWtx6tBOs//1VfybWr2KFKqV9f2blObElJy6hR/Senlzz/lQlxKikkwb95cfz2C8uX1lfvtN/noU1yvPHn49S9RwiQkKzU4lqhVi9tKKVHagilRCqWlS1s/lhBya9Tg2tgVKyyXl/5fIdh07ap9ngsUAH780Xo7BOPHm69r2BAICbEcF+TyZa511uvkIGx51KZetm0zCRLR0fxTaCKEtmTIEFN5awl8798HFizg94Nymmr0aODSJfX97I0LtmCBfWki9DpAlCypr1xaGk8LYY3gYJMNZUgIF8Jtmd6UCuR6aNrUtvI5CQkzdpCSAty6BYwaxW+69HTg3Dl9+6p5xOjhl1/4p+iMrWlDrl3jHcSoUfL1lkZ7YpQnXKXz5+fCgTWKFtWeGmvShI/ErBma/fOP6fv589btYSzx++/8JajG99/zOWqpqldw7Zr5OuVLcft23tkK1P63pSk3tWNI+ecfrvZXexnrsUUpXRr44w/r5QSHD/NRmt72Ada96ax5rgikgr6wG6hTh6vix483Te/pTfLaujUwfbr6SFfLdmrJEj76lwoN27eb27pJCQjgn/nyceEpKooPNrp1s9w+6TMrpp83bjTXTAqUUw3t25u+x8fzT2n8K/GOUEM5KJFORQtNnmifpVARxYsDO3bw71Jtjdo9/+ef/FPpLSedem/Y0PR93Tr1a5eWxgcrUhsrAJg/X7ud9mipS5Xi2kJrwnPTpvx+kgq8euLfiPsjXz597dFjnLthA29P3br82b14UdszDODvlenT+ftv4kT5+bfGM89YvsfcDQkzduDtzUfo27fz0YmWDQtgHpQoLc26ulnNRkC8QNUMyNQICOAdhHK09eabPIDVF1+Y7yM8qoRh8qxZlo/xyy98WqJZMz7CVFKgAJ+fVbqnSxHBqKTqzvv39Y9gtNAa8fXpw0fS1rRJAmXHHRFhXUPi7a1uQxEcDPToYf2YcXHAr7+ar7dmi9KkCR+Bh4RYP4YUcW8p0bJV2bVLu664OH0BxooVk0+Hift03z7+PwYO5PehUiNpie3buc2NLXZq4j9K9zl7Vu5pJcXHx/T8NmrEO77ly7UHF9bCDlgT1MS0R7VqpinA0FDTtJF0Ck6Z+G/SJJMGVTnKl4awVw54lAOuuXNN2opPPzVpuaQB+sRgrk0bk2ZGae8ihBrpuf7rL9P3zp3VO1ehtVMOUCwJBfZ46Zw6xd/l1rSL3t7cS/LiRVMYjU8+MTfkVSIESGfGbJLW5evL7881a7RtbtLSuBYpPh6YOtX2Y3maA4MUEmYcQBhPKXNbfP656bty7tPX1+TuN3iwer0iwJR0hBsTI19n7021axdXpSYlAT17yrepzdNa0pA89xzw1lv8e1CQuT1PpUrcGO+337Q1V2rup9J5ciW1a5u+d+qk3TZLxMaqR3R++WX+Wa4cH0W9+y7wv/+Zl5NGzBWjTylaU1wGg2XjbilqAknHjpZV4Hv3cuF60ybTOr2jQEHRoqZrdfasbfsC+j2/9MS2GTPGefFttOyILl3i3jTSadsDB0zPmxKt/yc951L0TCtb8gQUGiKtDMXKqR6prc+8edbtngoWNNcCKqfkhg5Vn6YaOND0XTq1oTXtfusW/7SUcVtNS6VlSG3JMN/HR32KXfr+UCLeCdu360+i+MEHvH0jRlifMrMVe+vz9ub/X3rNhICmFFxtiQAsFTw9ERJmHEA6UpAG/JJOQyjx8uKdfNeulh8sQB7jRWnFr3d+W/kSeuMN/jKZMMHcW0W88KV2HT17ao/cLbFzJ7cFmDyZvxhWr7ZcXvpfLXlJSNtiyUXQVlfx2rVN2iAvL27/YEkDIVDT0hw8yAU4JYxZ7uzffNP0Xc3o9Zdf+HmVopY5WTqFUKuWZc8OcX+sXw/MmSM3JPT35zY/euxHpOj1xJCei9RU/imeowMHbDumNbRsZrp25QK3VAN06JDzonL36ePY/mPG8Oty9qxJuExIMGn+lNoAqeFrQoLJzkTrfErtdcQ7Re15v36df0qfTXsjwUoHEnfvyreJ+0ALqaZU2dkrjbaVHTdgri2SIgTD/Pn5+RX/z5J20GAw2ZxZ07JdvMg/9U4DOxoiQepx+sUX8sGn4Kef9NfnDMN6V0LCjJNo0cJkhyFVo6p5yLz8Mu/cpSMbKWKUeOaMaZ3Q/uixaZBiaUqrQwe54CXcOKUv8hIl9Mf/EC+awoX5dzEqnTnTNNWk1KaI/ygV1izN+Urp3dtcVfrss9wuxp3qUEvuo1J3W6UGRzpdqSaM/fef7bFH9EZM7dQJGDZMvi45mbe3c2dtQ3A19Gpnnn/e9F10YmraQVvzotkTZ0lvm20V7NWEWlvw9+fXpUIFuRZGbwwS8ewqr+3Bg3ygsWCBvnqEh6Xa9KdehFAtnYK1FvU5MFA+3WnJkFtqnB8Son7fSN+pgPl5kdK6NRfklTZgWs4M1hCaDal9oBYFC9oXnVdgMMi9Bdu354Oh8HCTBjomBvjuO3PNXL58XNNor3u7uyBhxonMmMFf/O3amdYppeukJGDaNP6AzJ6tXk/r1rwzls6HCnWxuEFt9fZRIySEx8v44QceqVhrCkOvFkjtZSWYOpW/uJQeH8ImQDqnX7AgF0ikiI5eKii+8w4/H6tXmwSpbt30GS0rYcz0YhXTLPbGYJB6XViK1RIUZDKcrF6du6cOHcpTXWihdMUV2inli0cYi9rjmSEoVIh3ditW6O/EfHxMHX7fvuZqbDFaDA6WawUsdVIHD5rH4qhShQst77/P7SOkQv4bb6gLlNeuca8PLS2heFaVHhvffGP67qy4HNJpRDV3YDWkBsBalCwp1/iKKZ1mzUzeRQC3pZk0SR6HRgh0lrQXUmFa2gnaElPHkkef8j7w8+MCxYEDXLOhNjgUYRwqV+bfR4zg52DOHPOySsN/S4O92bP5MYV27cIFPu1uT+qW8uXVjdC1BAZXZqVesIBrZFau5PG1lPff+vX8XtNrn+kpkDDjRHr04HP8luwUUlK4vcCpU9pzvmXK8PnlmTNN64SAIDxP7BFmdu0yvdCk7ruvvsq1KOIBcsWD5OPDjxkYyDuauDie30V4Z0kNiEuVMlchC4FK+iL8/Xfu4RAXZ5qPV9MiiRegpVgbR4/aH3NBK0YGYG7QqJxaLFCAf/7zDx9Jzp3L7yOtaKkREXLNldjfkjumciQ4YYLJMFTNNkTYMYn7+MYN/XPrSlV//vxy7dC6dbxjiovj5yIzk3eillTqtWqZe1GULcuFlokT+f+zJAxVqWIKEPjaa+rG6t7efNT+0UfcyFWaf0ZMvUVE5Gw6CuWI2dvb8rulUCHuZq3ljaPXk1JNuJo7l59zqdeOtai44j6qUUPfcQHeiQoX806dTMJTvXpcqGnVyvxai4jOS5dy4XbWLP48qLnoHz0qTx3z7rv8PhIeWlK2beMeUyJaeJky/PrrCUQoZcgQPkBSMywWwtWSJaZ1pUu7VrOcNy93yRZT2UoN1v37fECu1HDmRHoFRyBhxgH0dPpKF8HQUNOIQe1hEyhf7r/8wgUgoa3Rm8VVOX2zYgW3g9ByVXWEEiV4JnAx1yy8otSs5iMj+QhHeERIz2W1avJOtmxZ9czawlVz5UrTC8cRtb49tkFqVK5sEj6lLqtlypj/Dy0PJaUtgRahoVyToFSFv/oqf7Frdb6zZ/NAhpY8s6RaIOmUkEArUNeWLfxTBEqU/ud9+3jHVLAgF2qGD7cvArQl4+R79+QdbalS/P66dIlP10rdriMiuDb1wAHe2YwbxwUGNbdxvR5wAP9PloRjIXxbQs09X+R6k7qBiwGOmkOB1IZGKnSrCSxDh/KgmWrCx9Ch3GbCFvupDRv4dIUwmBdC9b//au9jMPD7dvNmLmSoCUxaAeysxXAaPpwPaKQCYf78vNNW02B+9x0XRITG9swZPlWk59pJUXovSR0lnnuOT3VJHSHi4kyDVVunWO1BKaScPKluAK1HM+hW2BNGYmIiA8ASExNdfqxp00Q2Je0yCQmmMps383WmLEyW679921QuI0O+LT7etG3KFMYWLmTsyhXzOh4+NJVLTtb3v6ZPN2+f+B0Zqa8OwY0b+srdusXYoUOM/fsv/71okemYMTGMVaig3aZ69Rj75hvGKldmLC7OvG5Rrnlz/unjI18PMFanDmOjR/PvPXowVrw4P69qKK/ftm2M5cljWrdrF2Nt2/LvP/zAr8vffzN28yZj/fvL9y1VSv1euHRJfhyAsTlz+LbPPjOtS0tTb+OzzzLm5SU/j2L58UeLl8JY7vnnTd8nTzavp14983UAYwULyv/TyZOm359/bjrOvHl8XfXqpnWffqr9bCiPo8XFi/JyX38t379KFdP3tm3V67h/n98HGzbw37Gx6s+XoF07+TEDA/myYIH6ObK0fP89Y6dPqx8nM5Oxw4fl1/3aNX5/3bjB2Kuv8jpef52xffvk+6almY5h7bnMm5eXK1xYu0xiovZ/YIyxrVsZGzaMsaVL+W+xTXlPKpG289498+3iHundW15vaKi8nLJNkybx9dL3amam9v8TZZo0kf8eOVK9fGCg+rk4fFheLjJS/b9L97l9m6/z9ua/587VPtezZzP200/yugYN4tv27uXvHUtIzzfA2IAB2velq3Gk/ybNjAPUrcsle0tziyEh3Hju6lW5LY0epN5SatmrBRMm8JDklkKw28I775huYSW2JlzTE8US4BqVDh34qEzJ1q3WgxIOHMhHFGrpHiZP5iOv99/n3lnW4iuUKMGv14QJ6tvF6FQYJkZHmxs2C1X/9ev8ulSvzrUoSrdVLe2e2nkWZaW2D1oGwVlZ2q6dERE8fMCIEZaNEbWmNMLDefDFLl3Us5KLUa7IsyT1epH+fzF1JG2D0GSpeWnZGj/HEYKDue2SsPFp2NDy81W7tmn6oVcvbtv16JHJ2NISSiPtX3/l011qXmFeXvxY0uterBi/v8LDTcH/Fi0yT7Eg1fZai5B7/jx/b2nF2wHkU6HiP8TEmLS+hw7x6SnhFXj2LI/JI/UO0nN+9GItKrq93kFKTYzWNJ49efi0ENPl4r0vfeYFI0fyd97w4eaRfL/+mt8/TZpYzzQuPS99+sinrJ2VYDMn0GnaSagRHa3PlkAZS2XjRq4SVhq5KpFOJSnVjdJpiF9/5SpytZgtUi8NSwKRXpz5wCrrTUgwnU9L+amUWJvukyb+bNlSvczhw/JtluoULpZSpJFLIyJMUxm7dpmmBgDrgbUsIV46NWqoC5pSRJj3e/e48CW1EwBMbquVK5sbIV68yM//rVvq92h8PDeKrVuXx9k5e5Zft6ZNuXfct9/ybWoBApXeJEoCArgdga12CfZir3uxkg8/5Mvt21zQEFMr0g4/IMDkvuvryzubV1/lxrOXL3MhsEMH7o4NcHsNd2XODguznldO2tEJ4WjMGFPH+/ff/HPvXv5ZoQJfpFOrau8kqRB3757JLkwQHc2nypVRh62FBBDPpFToyciwP/WBXvR6yklRuqirRTSvV8/y/avXcUPKzJnyPHrJyTzI6tmz+iKQuxPSzLiBDh24d5JWxyoIDuaeHH//bS7MSB/c557jHlJqSB8KazEc9OCqbK7ixSe8ZrRyJbkSYdwobH1sQbh4vvUWt/ERNjOvvMI9TAwGbneitJnR6qzUYlZI82FZQ4yof/nFXMMifZkrQ8QDXPhRJuqT3n9SzyJfX66hkgp/BQsCY8fqdwuX0rAh195IA08KpKNPS/P3SkFIGuRQIGyyrMV60ku3bvx/b90q76Clwoz0mornaP16k01GjRpyWxh7nrXXXuOfUgFeINXUaRmYOxMRSFApwEoHRLbkERP8/juPyWRL3iop0rAHjsZykXLqFL+eIgt5167cwLhePXm5d97hBr5aoTnUkAqW69fzwcwrrzjeZkA+MGKM2wl17Mjtvry9ef68GTP0B/x0FyTMOMC2bVz6tTfugB7q1tXn76+l5ZF2Qs4wJtMTudUelMaS1hIDSnGGKrRWLT4dBZi8I2xBjILURkPCcHTHDpObp+iYhw7ln0othppXlrOCVul9KQmjYi8v/uJdupQLm2opKETnqGXQLAQgaWBANfbs4UbLanFt9N57+fNzYVgIBmrCaefOXD0vom07ysOHfPRsSUhQm5KTxtVxRpby+fP59VVzH5YKWc4I7SDtBIVRb5s2+lJ2COwJTpiZyQdmQuOhV4snpr+kmhhbPDdnzOBaIq04RpUqyaebX3iBa+uUxxg8mDuGSF3+tRDvNqnQVaYMf/YMBud4nkqF3Hv3uMfphg3aEeo9FRJmHODgQf5gSQOh5RTSvCiWKFyYd5jDhunfxxPQChgljQEiXhzOyHXy11/czffyZfXsw64iMJBPJ1pyubUU6VgLIWD3729uFyO1R7GkYhdaIzHl8MorXJBRS3Eh7Ai0AiyuXs33kya1tBVpgDVrHX/dunzqLy1NPd/PkCHco8tSXjVbEFqIpUvl2jdpRxsUZD7N2KuXycaoa1d5p2VPR+XtzaceXBmnRCAViKSu7GLKtV8//qm0KZTGerHHg1BceyGUq0XLBri2WjoQdHTKbtQoLoRo5SwTCDdvWzUZ1t5j4v3t4+PcQaX0XlE7R8I70R3aclsgYcYB7MnM6ixsmeedO1c9gJQt2JLwzx7GjuWf1jIPS3n2WT66dtTuoXBhfj4NBtOUkK0sXco/V67kn8JFXNoBq9m5DBrEbVNEvB2BVBUugrxp5f9R4/ff+eitVy8+bTNqlNym6rPP+G+hjVKjaFGu1dAyhLYFX1+ucbF2bkWQN7UXp7Tz1NtR5LTNSXo6FyiSk7m2Rnr8ypVNguSYMVybIbVPAPg579GDd2xanbQnUrWquZv/p58CP/9sHnDR359rAJKS7JvmWbWKfwqh+o03+KcyWObYsabpa8CkDZVO91myPRMu4NK0ALa0V0+kXynffWe+TpgGSG1moqLMg0g6gq8vfz8MGmR5atgWO0Z3QAbAhEfw3HM8Qqte7yeAP3yO8PAhN8Z2JGy4QHg8KCP0Kg33RHTf5ct5FM5ffuFTAy1amAQ6QD1mhtKI1xJBQabgeu3a8UUag2f0aPVEfFJCQ03GqDt3cluAsmX59Oo339g2569Gly581CfNcGzJI8VR4/Nq1XjCRrWYOc5GqoFp0oQLaVFRXEO6bx/XxqgNSAwGyxGgHUHaESuNal2Bvz+/xmpYOr60nc6I/XTqFBeoREoVaYwdS8JM69ZcKFXGcHIV0v+t1KKnpOhPK2MP0mCIWni6cE2aGQfIyWigSpwx520LeoP0OUKxYqYHWvlCF9Mm0lDr48fzF87GjfYdL08e7hrqjBf75s3cpXH7dv578WIuTMyaJS+nDIZ3+TLv0KUjSC0cte8QgQW1XEstIbIZX7jADYQfPZIHu7PnWahdm4+qpUKRXm8vezKm//MP77ysueY7m99+41qIZ5/l04nt2skFGZE8VE9iU0eQasWcYfgq/Q8+PibBRS3lgC1IbfvUhBnhHagWyVmN4sW5/YettnXffMM992y16xEDMkupTNSwdn02b+aegjnNsmV8qlYr/Y6nQJoZB+jZk0v5lqKouoqccl0VREfznB6O5PqxBaUnh1o6g927+SjX1VNgemjXTh4htk8f9YzJQ4fy+BBC5S2MEoWmRiB15/zrL/5i1fJYsxVnjPCU0zdCCLElQmy9euaeHu+9x1157cmv5anoFdAs5QnyRKTCgZiqKF+ea6IcwWAwvWfUDOr/9z++XbgKiwSO69ap1ydsmI4e5UK3PS7LtlC5MheCbI2LZDCYcowpNTMhISbbL0c1orbSo4dtRt3ugoQZB/Dy4oaE7iA4mMcSadaMd6LCHfBJoXVr04g1PFy9QxD2FcuW8Recp6MWdE0rC7pU/d2ggXoQudzO4cNciKtQwfSCLlyYpxawhoijYwt37nCNUoEC6lnJnYE9gf127OD3sD1edLYg9WZKSXG+Q4CPj3Om8Hx81HMlCQwG+dTkJ59w2xJpPCdLSKdLciJdgF6kWsNPP+X3qLc3v265TdB1ByTM5GJKleJqx7/+Ms/062z8/flUk1qOJFcgVVU3amRyS/7jj5w5vjM5f54HBIyI0J8Tq3hxfm1dMU9tS7wavQitlC12PUeOcEPk+vVtH20eP25becA0VVqlimnKzVl06MANtIXbui0880zOaDyl0xjO0E5IXXq1ok3nBGXK6M/qnhOIQZi1AJFqzJ/PPz/4wHUC95MKCTO5nJgY9czHzsZg4C9Ad4xkfv7Z8nZXR/B0lLJlTQLE+vX8U0wrffYZH82OHGm+nwiA5iyiovgLVi3lg6PYE4RNeKXo0cQAXOtha5K/nKJyZR4F2VroeHcitcNwRmwmaRBOe6Lc5jQ55dmWJw+3abTFmQGQC4TJyVxLKbRpaolBX3sNeP11+9v5pEHCTC7n3Dk+Ko6MdM2IW/D4MZ8H1pvN2VGs5WICuOZi2jT3GMXZi9KQuksXfk5zUwwgNYQbq1ZG4ycde6JG53akxrmePKAYPZoHcxQhHKTvsMxM50YBBvi766+/HLPlU0YAV0tn0KSJawO25jZc5s109+5d9OzZE/nz50eBAgUwYMAAPFQTLxXExsbimWeeQZ48eZA/f340b94cj1yVEOgJYPx4bpw7fbq7W+JctCLJSnntNe5d46worjnBvHk8nLl0miOnBBmh9pZGnc1NSGNrKNMt2IK1nENPKtKRv6vSkngin33GU1qIaTapE4GzBRmAe2W+8IJztdhSjZ9IAty3r/PqfxJwmTDTs2dPnDx5Etu2bcOGDRuwZ88eDLISGCQ2Nhbt2rVD27ZtceDAARw8eBDDhg2DlyvuuCcEoapXC7jkTMQ8sPh0NZ988mQ+rIUKccEzp2JXqKHHDVzJoEHco0oEBVQiphlcKSg5OpWxaRM3LF+40DntyW24Mp2BtcSnnoR0ii0nIiXrRdrNiSjJQuPlag+sJwGXnKLTp09jy5YtOHjwIOpm68HmzJmDDh064LPPPkMxjcQ7b775Jv73v/9hrCR6WMXcNOx+gklIyNnjFSoELFpkHiFVGRqd0E+VKjxyrj2us8WKWTbSFXmaRGZiVyCNgBwfb/v+7dtbTlD5pCO1GXGGNlCqaH/82LGM8AQXZq5c4fZnIr1JbhIS3Y1LVB6xsbEoUKCAUZABgOjoaHh5eWG/WppeAAkJCdi/fz9CQ0PRuHFjhIWFoUWLFtgr8sdrkJqaiqSkJNlCOB9lPJCc4sQJHrlTK7kb4RnYEl/GXqQvdnsC/z3t+PpyW44//nCOV6JUOPIkF2drSA2XPU1YiIiQ2z6K6cDERPe0JzfhEmEmPj4eoQqzfh8fHxQqVAjxGkOqixcvAgAmT56MgQMHYsuWLahduzZat26Nf0VKVhWmTZuG4OBg4xKhFszjCebDD/mnq6MzjhnDjRyd7dJqjSpV+H97Wu0cnIkrX9ydO/PpMxEBWQ8iim+FCvrKu1Lr87TQoIHzwjiEhPD3wtixOReywRm4Mi2Aq8jpiO+5EZuEmbFjx8JgMFhcztjjXA8gK9s67fXXX0e/fv1Qq1YtfP7556hYsSIWWpjkHjduHBITE43LVWkY1qeAd9/l7qoi74ir8PfnLy532XqI2UZHk0o+zZw6xT+PHXN+3QYDN2y2JXhj7do8SrI9EU3tiedCOJ9PP3VeZGqCcASbbGZGjx6NvlasMsuUKYPw8HAkKIwsMjIycPfuXYRrON8XzbZ4qqzorSpVqoQrIue7Cv7+/vB3RtCEXExO5E1yN1WrcvdET092lhtQc/N0B02aOB76niBsJTdNiQlyOn1NbsQmYSYkJAQhOuJ1N2rUCPfv38fhw4dRJzt1786dO5GVlYUGGnHZIyMjUaxYMZw9e1a2/ty5c2j/NFvtEUZykyqbcD579vC0FceO2WcATBCA3PjZ0x1lKZ2BflxyKStVqoR27dph4MCBOHDgAPbt24dhw4ahe/fuRk+ma9euISoqCgeyw38aDAa89dZbmD17NlavXo3z589jwoQJOHPmDAbYmraUIAhNXBEBOCdo1swUI0R4TxEEQQAujAC8dOlSDBs2DK1bt4aXlxe6du2K2RIr1fT0dJw9exYpKSnGdSNHjsTjx4/x5ptv4u7du6hRowa2bduGsq4MbUsQTwmVKgGnT+eM5xFBEI4jYgNJuklCA5cJM4UKFcKyZcs0t0dGRoKpuFeMHTtWFmeGIAhCEBVlypZOEPYgFQwY86zAeVp4ip2bJ0NxBQniKeHCBf6Zm908GzcGFiwAOnZ0d0uI3ErJksCIEdwGz9NtZgQ6TFWfekiYIYinBJHZmkKjE087s2a5uwX68PHhaTxyKuN3boZeawTxlHD+PI81ExPj7pbYj8g5S2p3giCkkDBDEE8JZcvKQ6XnRv74g3+S3QzxNCBN4KqR0pDIhoQZgiByDV98wfPVDBrk7pYQRM5B3kzWIWGGIIhcQ1gYsGaNu1tBEDlDr17Af/8BNWu6uyWeDwkzBEEQBOGBfP+9u1uQe8gljmkEQRAEQRDqkDBDEARBEESuhoQZgiAIgiByNSTMEARBEASRqyFhhiAIgiCIXA0JMwRBEARB5GpImCEIgiAIIldDwgxBEARBELkaEmYIgiAIgsjVkDBDEARBEESuhoQZgiAIgiByNSTMEARBEASRqyFhhiAIgiCIXA0JMwRBEARB5Gp83N0AZ8MYAwAkJSW5uSUEQRAEQehF9NuiH7eFJ06YefDgAQAgIiLCzS0hCIIgCMJWHjx4gODgYJv2MTB7RCAPJisrC9evX0e+fPlgMBicWndSUhIiIiJw9epV5M+f36l1EyboPOcMdJ5zBjrPOQed65zBVeeZMYYHDx6gWLFi8PKyzQrmidPMeHl5oUSJEi49Rv78+elByQHoPOcMdJ5zBjrPOQed65zBFefZVo2MgAyACYIgCILI1ZAwQxAEQRBEroaEGRvw9/fHpEmT4O/v7+6mPNHQec4Z6DznDHSecw461zmDJ57nJ84AmCAIgiCIpwvSzBAEQRAEkashYYYgCIIgiFwNCTMEQRAEQeRqSJghCIIgCCJXQ8KMTr788ktERkYiICAADRo0wIEDB9zdJI9h2rRpqFevHvLly4fQ0FB06dIFZ8+elZV5/Pgxhg4disKFCyNv3rzo2rUrbt68KStz5coVdOzYEUFBQQgNDcVbb72FjIwMWZndu3ejdu3a8Pf3R7ly5bB48WKz9jwt12r69OkwGAwYOXKkcR2dZ+dx7do1vPrqqyhcuDACAwNRrVo1HDp0yLidMYaJEyeiaNGiCAwMRHR0NP79919ZHXfv3kXPnj2RP39+FChQAAMGDMDDhw9lZf755x80a9YMAQEBiIiIwCeffGLWllWrViEqKgoBAQGoVq0aNm3a5Jo/ncNkZmZiwoQJKF26NAIDA1G2bFlMnTpVlpuHzrPt7NmzB506dUKxYsVgMBiwbt062XZPOqd62qILRlhl+fLlzM/Pjy1cuJCdPHmSDRw4kBUoUIDdvHnT3U3zCGJiYtiiRYvYiRMn2LFjx1iHDh1YyZIl2cOHD41lBg8ezCIiItiOHTvYoUOHWMOGDVnjxo2N2zMyMljVqlVZdHQ0O3r0KNu0aRMrUqQIGzdunLHMxYsXWVBQEBs1ahQ7deoUmzNnDvP29mZbtmwxlnlartWBAwdYZGQkq169OhsxYoRxPZ1n53D37l1WqlQp1rdvX7Z//3528eJFtnXrVnb+/HljmenTp7Pg4GC2bt069vfff7PnnnuOlS5dmj169MhYpl27dqxGjRrsr7/+Yn/88QcrV64c69Gjh3F7YmIiCwsLYz179mQnTpxgP/30EwsMDGRff/21scy+ffuYt7c3++STT9ipU6fY+PHjma+vLzt+/HjOnAwX8uGHH7LChQuzDRs2sLi4OLZq1SqWN29e9sUXXxjL0Hm2nU2bNrH33nuPrV27lgFgP//8s2y7J51TPW3RAwkzOqhfvz4bOnSo8XdmZiYrVqwYmzZtmhtb5bkkJCQwAOz3339njDF2//595uvry1atWmUsc/r0aQaAxcbGMsb4w+fl5cXi4+ONZebNm8fy58/PUlNTGWOMvf3226xKlSqyY3Xr1o3FxMQYfz8N1+rBgwesfPnybNu2baxFixZGYYbOs/N45513WNOmTTW3Z2VlsfDwcPbpp58a192/f5/5+/uzn376iTHG2KlTpxgAdvDgQWOZzZs3M4PBwK5du8YYY+yrr75iBQsWNJ57ceyKFSsaf7/88susY8eOsuM3aNCAvf766479SQ+gY8eOrH///rJ1L7zwAuvZsydjjM6zM1AKM550TvW0RS80zWSFtLQ0HD58GNHR0cZ1Xl5eiI6ORmxsrBtb5rkkJiYCAAoVKgQAOHz4MNLT02XnMCoqCiVLljSew9jYWFSrVg1hYWHGMjExMUhKSsLJkyeNZaR1iDKijqflWg0dOhQdO3Y0Oxd0np3H+vXrUbduXbz00ksIDQ1FrVq18O233xq3x8XFIT4+XnYOgoOD0aBBA9m5LlCgAOrWrWssEx0dDS8vL+zfv99Ypnnz5vDz8zOWiYmJwdmzZ3Hv3j1jGUvXIzfTuHFj7NixA+fOnQMA/P3339i7dy/at28PgM6zK/Ckc6qnLXohYcYKt2/fRmZmpuzlDwBhYWGIj493U6s8l6ysLIwcORJNmjRB1apVAQDx8fHw8/NDgQIFZGWl5zA+Pl71HIttlsokJSXh0aNHT8W1Wr58OY4cOYJp06aZbaPz7DwuXryIefPmoXz58ti6dSuGDBmC//3vf1iyZAkA07mydA7i4+MRGhoq2+7j44NChQo55Xo8Ced67Nix6N69O6KiouDr64tatWph5MiR6NmzJwA6z67Ak86pnrbo5YnLmk24l6FDh+LEiRPYu3evu5vyxHH16lWMGDEC27ZtQ0BAgLub80STlZWFunXr4qOPPgIA1KpVCydOnMD8+fPRp08fN7fuyWHlypVYunQpli1bhipVquDYsWMYOXIkihUrRueZsAnSzFihSJEi8Pb2NvMIuXnzJsLDw93UKs9k2LBh2LBhA3bt2oUSJUoY14eHhyMtLQ3379+XlZeew/DwcNVzLLZZKpM/f34EBgY+8dfq8OHDSEhIQO3ateHj4wMfHx/8/vvvmD17Nnx8fBAWFkbn2UkULVoUlStXlq2rVKkSrly5AsB0riydg/DwcCQkJMi2Z2Rk4O7du065Hk/CuX7rrbeM2plq1aqhV69eePPNN42aRzrP/2/vbkKi2t84gH9HxznNTJlTU2qCpWRmRi9oyUE3JZS2KTGiGGRqI2qKi142JtpCcBG2iBCEskWSZGQZkmFqRIJa4ctEk7WpFim9Ib5VCPPcxaXDPVf/96/3Oo5Hvx84MHN+z5x5fs/BmYeZ8xvn32Kq6WxymS02M/+HxWJBUlIS2tratH0+nw9tbW1QVTWAmS0eIoLCwkI0Njaivb0dMTExuvGkpCSEhIToajg4OIiPHz9qNVRVFR6PR/cH1NraitDQUO1NRVVV3TF+x/w+xlI/V+np6fB4POjr69O25ORkuFwu7TbrPD9SU1On/bzA27dvsXHjRgBATEwMIiIidDUYHR1Fd3e3rtYjIyN4+fKlFtPe3g6fz4eUlBQt5unTp5iamtJiWltbER8fD4fDocX80/kwssnJSQQF6d+GgoOD4fP5ALDO/rCYajqbXGZtTpcLL1P19fWiKIrcuHFDXr9+Lbm5uRIWFqZbEbKc5efny+rVq+XJkycyNDSkbZOTk1pMXl6eREdHS3t7u7x48UJUVRVVVbXx30uGDxw4IH19fdLS0iLr1q2bccnwuXPnxOv1ytWrV2dcMrycztVfVzOJsM7zpaenR8xms1RUVMi7d++krq5ObDab3Lx5U4uprKyUsLAwuX//vgwMDMjhw4dnXN66e/du6e7ulmfPnklcXJxueevIyIiEh4dLTk6OvHr1Surr68Vms01b3mo2m+XSpUvi9XqlrKzMsEuG/87tdktUVJS2NPvu3bvidDrl/PnzWgzrPHdjY2PS29srvb29AkCqqqqkt7dXPnz4ICKLq6azyWU22MzM0pUrVyQ6OlosFovs3btXurq6Ap3SogFgxq22tlaL+fHjhxQUFIjD4RCbzSZZWVkyNDSkO8779+8lMzNTrFarOJ1OOXPmjExNTeliOjo6ZNeuXWKxWCQ2Nlb3HL8tp3P192aGdZ4/Dx48kO3bt4uiKLJ161apqanRjft8PiktLZXw8HBRFEXS09NlcHBQF/Pt2zc5ceKErFy5UkJDQ+XUqVMyNjami+nv75e0tDRRFEWioqKksrJyWi63b9+WLVu2iMVikcTERGlubp7/CQfA6OioFBcXS3R0tKxYsUJiY2OlpKREt9yXdZ67jo6OGV+T3W63iCyums4ml9kwifzlpxaJiIiIDIbXzBAREZGhsZkhIiIiQ2MzQ0RERIbGZoaIiIgMjc0MERERGRqbGSIiIjI0NjNERERkaGxmiIiIyNDYzBDRkmcymXDv3r1Ap0FEfsJmhoj86uTJkzCZTNO2jIyMQKdGREuEOdAJENHSl5GRgdraWt0+RVEClA0RLTX8ZIaI/E5RFEREROg2h8MB4M+vgKqrq5GZmQmr1YrY2FjcuXNH93iPx4P9+/fDarVi7dq1yM3Nxfj4uC7m+vXrSExMhKIoiIyMRGFhoW7869evyMrKgs1mQ1xcHJqamvw7aSJaMGxmiCjgSktLkZ2djf7+frhcLhw/fhxerxcAMDExgYMHD8LhcOD58+doaGjA48ePdc1KdXU1Tp8+jdzcXHg8HjQ1NWHz5s2657h48SKOHTuGgYEBHDp0CC6XC9+/f1/QeRKRn8z5/2wTEc2B2+2W4OBgsdvtuq2iokJERABIXl6e7jEpKSmSn58vIiI1NTXicDhkfHxcG29ubpagoCAZHh4WEZENGzZISUnJ/8wBgFy4cEG7Pz4+LgDk4cOH8zZPIgocXjNDRH63b98+VFdX6/atWbNGu62qqm5MVVX09fUBALxeL3bu3Am73a6Np6amwufzYXBwECaTCZ8+fUJ6evo/5rBjxw7ttt1uR2hoKD5//vxvp0REiwibGSLyO7vdPu1rn/litVpnFRcSEqK7bzKZ4PP5/JESES0wXjNDRAHX1dU17X5CQgIAICEhAf39/ZiYmNDGOzs7ERQUhPj4eKxatQqbNm1CW1vbguZMRIsHP5khIr/79esXhoeHdfvMZjOcTicAoKGhAcnJyUhLS0NdXR16enpw7do1AIDL5UJZWRncbjfKy8vx5csXFBUVIScnB+Hh4QCA8vJy5OXlYf369cjMzMTY2Bg6OztRVFS0sBMlooBgM0NEftfS0oLIyEjdvvj4eLx58wbAnyuN6uvrUVBQgMjISNy6dQvbtm0DANhsNjx69AjFxcXYs2cPbDYbsrOzUVVVpR3L7Xbj58+fuHz5Ms6ePQun04mjR48u3ASJKKBMIiKBToKIli+TyYTGxkYcOXIk0KkQkUHxmhkiIiIyNDYzREREZGi8ZoaIAorfdBPRf8VPZoiIiMjQ2MwQERGRobGZISIiIkNjM0NERESGxmaGiIiIDI3NDBERERkamxkiIiIyNDYzREREZGh/AF3jL+QLENcsAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(np.mean(reward_list, axis=1), 'b-', label='Average')\n",
    "plt.plot(np.mean(reward_list, axis=1) + np.std(reward_list, axis=1), 'b--')\n",
    "plt.plot(np.mean(reward_list, axis=1) - np.std(reward_list, axis=1), 'b--')\n",
    "plt.plot(np.median(reward_list, axis=1), 'r--', label='Median')\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.ylabel(\"Normalized Reward\")\n",
    "plt.legend(loc=\"upper right\")\n",
    "plt.show()\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(np.mean(action_list[:, :, 0], axis=1), 'b-', label='Linear Velocity')\n",
    "plt.plot(np.mean(action_list[:, :, 0], axis=1) + 5 * np.std(action_list[:, :, 0], axis=1), 'b--')\n",
    "plt.plot(np.mean(action_list[:, :, 0], axis=1) - 5 * np.std(action_list[:, :, 0], axis=1), 'b--')\n",
    "\n",
    "plt.plot(np.mean(action_list[:, :, 1], axis=1), 'r-', label='Angular Velocity')\n",
    "plt.plot(np.mean(action_list[:, :, 1], axis=1) + 5 * np.std(action_list[:, :, 1], axis=1), 'r--')\n",
    "plt.plot(np.mean(action_list[:, :, 1], axis=1) - 5 * np.std(action_list[:, :, 1], axis=1), 'r--')\n",
    "\n",
    "plt.legend(loc=\"upper right\")\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "0\n",
      "2\n",
      "tensor(0.0714, grad_fn=<AddBackward0>)\n",
      "4\n",
      "tensor(0.0784, grad_fn=<AddBackward0>)\n",
      "6\n",
      "tensor(0.0536, grad_fn=<AddBackward0>)\n",
      "8\n",
      "tensor(0.0750, grad_fn=<AddBackward0>)\n",
      "10\n",
      "tensor(0.0622, grad_fn=<AddBackward0>)\n",
      "12\n",
      "tensor(0.0631, grad_fn=<AddBackward0>)\n",
      "14\n",
      "tensor(0.0503, grad_fn=<AddBackward0>)\n",
      "16\n",
      "tensor(0.0184, grad_fn=<AddBackward0>)\n",
      "18\n",
      "tensor(0.0812, grad_fn=<AddBackward0>)\n",
      "20\n",
      "tensor(0.0585, grad_fn=<AddBackward0>)\n",
      "22\n",
      "tensor(0.0815, grad_fn=<AddBackward0>)\n",
      "24\n",
      "tensor(0.0649, grad_fn=<AddBackward0>)\n",
      "26\n",
      "tensor(0.0644, grad_fn=<AddBackward0>)\n",
      "28\n",
      "tensor(0.0780, grad_fn=<AddBackward0>)\n",
      "30\n",
      "tensor(0.0626, grad_fn=<AddBackward0>)\n",
      "32\n",
      "tensor(0.0559, grad_fn=<AddBackward0>)\n",
      "34\n",
      "tensor(0.0720, grad_fn=<AddBackward0>)\n",
      "36\n",
      "tensor(0.0649, grad_fn=<AddBackward0>)\n",
      "38\n",
      "tensor(0.0615, grad_fn=<AddBackward0>)\n",
      "40\n",
      "tensor(0.0941, grad_fn=<AddBackward0>)\n",
      "42\n",
      "tensor(0.0679, grad_fn=<AddBackward0>)\n",
      "44\n",
      "tensor(0.0865, grad_fn=<AddBackward0>)\n",
      "46\n",
      "tensor(0.0679, grad_fn=<AddBackward0>)\n",
      "48\n",
      "tensor(0.1057, grad_fn=<AddBackward0>)\n",
      "50\n",
      "tensor(0.0957, grad_fn=<AddBackward0>)\n",
      "52\n",
      "tensor(0.0657, grad_fn=<AddBackward0>)\n",
      "54\n",
      "tensor(0.0757, grad_fn=<AddBackward0>)\n",
      "56\n",
      "tensor(0.0861, grad_fn=<AddBackward0>)\n",
      "58\n",
      "tensor(0.0744, grad_fn=<AddBackward0>)\n",
      "60\n",
      "tensor(0.0882, grad_fn=<AddBackward0>)\n",
      "62\n",
      "tensor(0.0782, grad_fn=<AddBackward0>)\n",
      "64\n",
      "tensor(0.0852, grad_fn=<AddBackward0>)\n",
      "66\n",
      "tensor(0.0692, grad_fn=<AddBackward0>)\n",
      "68\n",
      "tensor(0.0507, grad_fn=<AddBackward0>)\n",
      "70\n",
      "tensor(0.0723, grad_fn=<AddBackward0>)\n",
      "72\n",
      "tensor(0.0842, grad_fn=<AddBackward0>)\n",
      "74\n",
      "tensor(0.0645, grad_fn=<AddBackward0>)\n",
      "76\n",
      "tensor(0.0620, grad_fn=<AddBackward0>)\n",
      "78\n",
      "tensor(0.0736, grad_fn=<AddBackward0>)\n",
      "80\n",
      "tensor(0.0775, grad_fn=<AddBackward0>)\n",
      "82\n",
      "tensor(0.0623, grad_fn=<AddBackward0>)\n",
      "84\n",
      "tensor(0.0771, grad_fn=<AddBackward0>)\n",
      "86\n",
      "tensor(0.0606, grad_fn=<AddBackward0>)\n",
      "88\n",
      "tensor(0.0810, grad_fn=<AddBackward0>)\n",
      "90\n",
      "tensor(0.0280, grad_fn=<AddBackward0>)\n",
      "92\n",
      "tensor(0.0861, grad_fn=<AddBackward0>)\n",
      "94\n",
      "tensor(0.0775, grad_fn=<AddBackward0>)\n",
      "96\n",
      "tensor(0.0686, grad_fn=<AddBackward0>)\n",
      "98\n",
      "tensor(0.0718, grad_fn=<AddBackward0>)\n",
      "100\n",
      "tensor(0.0698, grad_fn=<AddBackward0>)\n",
      "102\n",
      "tensor(0.0715, grad_fn=<AddBackward0>)\n",
      "104\n",
      "tensor(0.1096, grad_fn=<AddBackward0>)\n",
      "106\n",
      "tensor(0.0730, grad_fn=<AddBackward0>)\n",
      "108\n",
      "tensor(0.0751, grad_fn=<AddBackward0>)\n",
      "110\n",
      "tensor(0.0678, grad_fn=<AddBackward0>)\n",
      "112\n",
      "tensor(0.0622, grad_fn=<AddBackward0>)\n",
      "114\n",
      "tensor(0.0591, grad_fn=<AddBackward0>)\n",
      "116\n",
      "tensor(0.0625, grad_fn=<AddBackward0>)\n",
      "118\n",
      "tensor(0.1472, grad_fn=<AddBackward0>)\n",
      "120\n",
      "tensor(0.0764, grad_fn=<AddBackward0>)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_985998/752440060.py:82: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  reward_list.append(np.float(reward_sum))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "122\n",
      "tensor(0.0827, grad_fn=<AddBackward0>)\n",
      "124\n",
      "tensor(0.0765, grad_fn=<AddBackward0>)\n",
      "126\n",
      "tensor(0.1131, grad_fn=<AddBackward0>)\n",
      "128\n",
      "tensor(0.0673, grad_fn=<AddBackward0>)\n",
      "130\n",
      "tensor(0.0760, grad_fn=<AddBackward0>)\n",
      "132\n",
      "tensor(0.0637, grad_fn=<AddBackward0>)\n",
      "134\n",
      "tensor(0.0724, grad_fn=<AddBackward0>)\n",
      "136\n",
      "tensor(0.0753, grad_fn=<AddBackward0>)\n",
      "138\n",
      "tensor(0.0391, grad_fn=<AddBackward0>)\n",
      "140\n",
      "tensor(0.0621, grad_fn=<AddBackward0>)\n",
      "142\n",
      "tensor(0.0412, grad_fn=<AddBackward0>)\n",
      "144\n",
      "tensor(0.0743, grad_fn=<AddBackward0>)\n",
      "146\n",
      "tensor(0.0732, grad_fn=<AddBackward0>)\n",
      "148\n",
      "tensor(0.0678, grad_fn=<AddBackward0>)\n",
      "150\n",
      "tensor(0.0740, grad_fn=<AddBackward0>)\n",
      "152\n",
      "tensor(0.0510, grad_fn=<AddBackward0>)\n",
      "154\n",
      "tensor(0.0659, grad_fn=<AddBackward0>)\n",
      "156\n",
      "tensor(0.0233, grad_fn=<AddBackward0>)\n",
      "158\n",
      "tensor(0.0707, grad_fn=<AddBackward0>)\n",
      "160\n",
      "tensor(0.0689, grad_fn=<AddBackward0>)\n",
      "162\n",
      "tensor(0.0583, grad_fn=<AddBackward0>)\n",
      "164\n",
      "tensor(0.0723, grad_fn=<AddBackward0>)\n",
      "166\n",
      "tensor(0.0617, grad_fn=<AddBackward0>)\n",
      "168\n",
      "tensor(0.0721, grad_fn=<AddBackward0>)\n",
      "170\n",
      "tensor(0.0840, grad_fn=<AddBackward0>)\n",
      "172\n",
      "tensor(0.0806, grad_fn=<AddBackward0>)\n",
      "174\n",
      "tensor(0.0657, grad_fn=<AddBackward0>)\n",
      "176\n",
      "tensor(0.0814, grad_fn=<AddBackward0>)\n",
      "178\n",
      "tensor(0.0671, grad_fn=<AddBackward0>)\n",
      "180\n",
      "tensor(0.0717, grad_fn=<AddBackward0>)\n",
      "182\n",
      "tensor(0.0503, grad_fn=<AddBackward0>)\n",
      "184\n",
      "tensor(0.0614, grad_fn=<AddBackward0>)\n",
      "186\n",
      "tensor(0.0630, grad_fn=<AddBackward0>)\n",
      "188\n",
      "tensor(0.0658, grad_fn=<AddBackward0>)\n",
      "190\n",
      "tensor(0.0781, grad_fn=<AddBackward0>)\n",
      "192\n",
      "tensor(0.0907, grad_fn=<AddBackward0>)\n",
      "194\n",
      "tensor(0.0549, grad_fn=<AddBackward0>)\n",
      "196\n",
      "tensor(0.0816, grad_fn=<AddBackward0>)\n",
      "198\n",
      "tensor(0.0755, grad_fn=<AddBackward0>)\n",
      "200\n",
      "tensor(0.0648, grad_fn=<AddBackward0>)\n",
      "202\n",
      "tensor(0.0633, grad_fn=<AddBackward0>)\n",
      "204\n",
      "tensor(0.0730, grad_fn=<AddBackward0>)\n",
      "206\n",
      "tensor(0.0792, grad_fn=<AddBackward0>)\n",
      "208\n",
      "tensor(0.0662, grad_fn=<AddBackward0>)\n",
      "210\n",
      "tensor(0.1613, grad_fn=<AddBackward0>)\n",
      "212\n",
      "tensor(0.0599, grad_fn=<AddBackward0>)\n",
      "214\n",
      "tensor(0.0851, grad_fn=<AddBackward0>)\n",
      "216\n",
      "tensor(0.0600, grad_fn=<AddBackward0>)\n",
      "218\n",
      "tensor(0.0595, grad_fn=<AddBackward0>)\n",
      "220\n",
      "tensor(0.0884, grad_fn=<AddBackward0>)\n",
      "222\n",
      "tensor(0.0710, grad_fn=<AddBackward0>)\n",
      "224\n",
      "tensor(0.0689, grad_fn=<AddBackward0>)\n",
      "226\n",
      "tensor(0.3078, grad_fn=<AddBackward0>)\n",
      "228\n",
      "tensor(0.0582, grad_fn=<AddBackward0>)\n",
      "230\n",
      "tensor(0.0638, grad_fn=<AddBackward0>)\n",
      "232\n",
      "tensor(0.0709, grad_fn=<AddBackward0>)\n",
      "234\n",
      "tensor(0.1088, grad_fn=<AddBackward0>)\n",
      "236\n",
      "tensor(0.0712, grad_fn=<AddBackward0>)\n",
      "238\n",
      "tensor(0.0686, grad_fn=<AddBackward0>)\n",
      "240\n",
      "tensor(0.0690, grad_fn=<AddBackward0>)\n",
      "242\n",
      "tensor(0.0643, grad_fn=<AddBackward0>)\n",
      "244\n",
      "tensor(0.0637, grad_fn=<AddBackward0>)\n",
      "246\n",
      "tensor(0.0838, grad_fn=<AddBackward0>)\n",
      "248\n",
      "tensor(0.1173, grad_fn=<AddBackward0>)\n",
      "250\n",
      "tensor(0.0729, grad_fn=<AddBackward0>)\n",
      "252\n",
      "tensor(0.0762, grad_fn=<AddBackward0>)\n",
      "254\n",
      "tensor(0.0567, grad_fn=<AddBackward0>)\n",
      "256\n",
      "tensor(0.0682, grad_fn=<AddBackward0>)\n",
      "258\n",
      "tensor(0.0789, grad_fn=<AddBackward0>)\n",
      "260\n",
      "tensor(0.0858, grad_fn=<AddBackward0>)\n",
      "262\n",
      "tensor(0.1002, grad_fn=<AddBackward0>)\n",
      "264\n",
      "tensor(0.1233, grad_fn=<AddBackward0>)\n",
      "266\n",
      "tensor(0.0657, grad_fn=<AddBackward0>)\n",
      "268\n",
      "tensor(0.0612, grad_fn=<AddBackward0>)\n",
      "270\n",
      "tensor(0.0761, grad_fn=<AddBackward0>)\n",
      "272\n",
      "tensor(0.0350, grad_fn=<AddBackward0>)\n",
      "274\n",
      "tensor(0.0883, grad_fn=<AddBackward0>)\n",
      "276\n",
      "tensor(0.0883, grad_fn=<AddBackward0>)\n",
      "278\n",
      "tensor(0.0793, grad_fn=<AddBackward0>)\n",
      "280\n",
      "tensor(0.0844, grad_fn=<AddBackward0>)\n",
      "282\n",
      "tensor(0.0846, grad_fn=<AddBackward0>)\n",
      "284\n",
      "tensor(0.0994, grad_fn=<AddBackward0>)\n",
      "286\n",
      "tensor(0.0679, grad_fn=<AddBackward0>)\n",
      "288\n",
      "tensor(0.0724, grad_fn=<AddBackward0>)\n",
      "290\n",
      "tensor(0.0880, grad_fn=<AddBackward0>)\n",
      "292\n",
      "tensor(0.0776, grad_fn=<AddBackward0>)\n",
      "294\n",
      "tensor(0.0478, grad_fn=<AddBackward0>)\n",
      "296\n",
      "tensor(0.0978, grad_fn=<AddBackward0>)\n",
      "298\n",
      "tensor(0.0617, grad_fn=<AddBackward0>)\n",
      "300\n",
      "tensor(0.0810, grad_fn=<AddBackward0>)\n",
      "302\n",
      "tensor(0.0877, grad_fn=<AddBackward0>)\n",
      "304\n",
      "tensor(0.0500, grad_fn=<AddBackward0>)\n",
      "306\n",
      "tensor(0.0514, grad_fn=<AddBackward0>)\n",
      "308\n",
      "tensor(0.0631, grad_fn=<AddBackward0>)\n",
      "310\n",
      "tensor(0.1084, grad_fn=<AddBackward0>)\n",
      "312\n",
      "tensor(0.0673, grad_fn=<AddBackward0>)\n",
      "314\n",
      "tensor(0.0693, grad_fn=<AddBackward0>)\n",
      "316\n",
      "tensor(0.0718, grad_fn=<AddBackward0>)\n",
      "318\n",
      "tensor(0.0820, grad_fn=<AddBackward0>)\n",
      "320\n",
      "tensor(0.0799, grad_fn=<AddBackward0>)\n",
      "322\n",
      "tensor(0.0654, grad_fn=<AddBackward0>)\n",
      "324\n",
      "tensor(0.0675, grad_fn=<AddBackward0>)\n",
      "326\n",
      "tensor(0.0634, grad_fn=<AddBackward0>)\n",
      "328\n",
      "tensor(0.0685, grad_fn=<AddBackward0>)\n",
      "330\n",
      "tensor(0.0883, grad_fn=<AddBackward0>)\n",
      "332\n",
      "tensor(0.0792, grad_fn=<AddBackward0>)\n",
      "334\n",
      "tensor(0.0575, grad_fn=<AddBackward0>)\n",
      "336\n",
      "tensor(0.0535, grad_fn=<AddBackward0>)\n",
      "338\n",
      "tensor(0.0794, grad_fn=<AddBackward0>)\n",
      "340\n",
      "tensor(0.0748, grad_fn=<AddBackward0>)\n",
      "342\n",
      "tensor(0.0658, grad_fn=<AddBackward0>)\n",
      "344\n",
      "tensor(0.0655, grad_fn=<AddBackward0>)\n",
      "346\n",
      "tensor(0.0860, grad_fn=<AddBackward0>)\n",
      "348\n",
      "tensor(0.0859, grad_fn=<AddBackward0>)\n",
      "350\n",
      "tensor(0.0963, grad_fn=<AddBackward0>)\n",
      "352\n",
      "tensor(0.0793, grad_fn=<AddBackward0>)\n",
      "354\n",
      "tensor(0.0717, grad_fn=<AddBackward0>)\n",
      "356\n",
      "tensor(0.0695, grad_fn=<AddBackward0>)\n",
      "358\n",
      "tensor(0.0846, grad_fn=<AddBackward0>)\n",
      "360\n",
      "tensor(0.0774, grad_fn=<AddBackward0>)\n",
      "362\n",
      "tensor(0.0788, grad_fn=<AddBackward0>)\n",
      "364\n",
      "tensor(0.0862, grad_fn=<AddBackward0>)\n",
      "366\n",
      "tensor(0.0316, grad_fn=<AddBackward0>)\n",
      "368\n",
      "tensor(0.0729, grad_fn=<AddBackward0>)\n",
      "370\n",
      "tensor(0.0785, grad_fn=<AddBackward0>)\n",
      "372\n",
      "tensor(0.0644, grad_fn=<AddBackward0>)\n",
      "374\n",
      "tensor(0.0602, grad_fn=<AddBackward0>)\n",
      "376\n",
      "tensor(0.0813, grad_fn=<AddBackward0>)\n",
      "378\n",
      "tensor(0.0793, grad_fn=<AddBackward0>)\n",
      "380\n",
      "tensor(0.0656, grad_fn=<AddBackward0>)\n",
      "382\n",
      "tensor(0.1011, grad_fn=<AddBackward0>)\n",
      "384\n",
      "tensor(0.0956, grad_fn=<AddBackward0>)\n",
      "386\n",
      "tensor(0.0769, grad_fn=<AddBackward0>)\n",
      "388\n",
      "tensor(0.0779, grad_fn=<AddBackward0>)\n",
      "390\n",
      "tensor(0.0542, grad_fn=<AddBackward0>)\n",
      "392\n",
      "tensor(0.0746, grad_fn=<AddBackward0>)\n",
      "394\n",
      "tensor(0.0916, grad_fn=<AddBackward0>)\n",
      "396\n",
      "tensor(0.0589, grad_fn=<AddBackward0>)\n",
      "398\n",
      "tensor(0.0619, grad_fn=<AddBackward0>)\n",
      "400\n",
      "tensor(0.0516, grad_fn=<AddBackward0>)\n",
      "402\n",
      "tensor(0.0839, grad_fn=<AddBackward0>)\n",
      "404\n",
      "tensor(0.1749, grad_fn=<AddBackward0>)\n",
      "406\n",
      "tensor(0.0530, grad_fn=<AddBackward0>)\n",
      "408\n",
      "tensor(0.0640, grad_fn=<AddBackward0>)\n",
      "410\n",
      "tensor(0.0863, grad_fn=<AddBackward0>)\n",
      "412\n",
      "tensor(0.0683, grad_fn=<AddBackward0>)\n",
      "414\n",
      "tensor(0.0686, grad_fn=<AddBackward0>)\n",
      "416\n",
      "tensor(0.0854, grad_fn=<AddBackward0>)\n",
      "418\n",
      "tensor(0.0658, grad_fn=<AddBackward0>)\n",
      "420\n",
      "tensor(0.0638, grad_fn=<AddBackward0>)\n",
      "422\n",
      "tensor(0.0698, grad_fn=<AddBackward0>)\n",
      "424\n",
      "tensor(0.0614, grad_fn=<AddBackward0>)\n",
      "426\n",
      "tensor(0.0688, grad_fn=<AddBackward0>)\n",
      "428\n",
      "tensor(0.0647, grad_fn=<AddBackward0>)\n",
      "430\n",
      "tensor(0.0563, grad_fn=<AddBackward0>)\n",
      "432\n",
      "tensor(0.0772, grad_fn=<AddBackward0>)\n",
      "434\n",
      "tensor(0.0771, grad_fn=<AddBackward0>)\n",
      "436\n",
      "tensor(0.0995, grad_fn=<AddBackward0>)\n",
      "438\n",
      "tensor(0.0647, grad_fn=<AddBackward0>)\n",
      "440\n",
      "tensor(0.0788, grad_fn=<AddBackward0>)\n",
      "442\n",
      "tensor(0.0702, grad_fn=<AddBackward0>)\n",
      "444\n",
      "tensor(0.0561, grad_fn=<AddBackward0>)\n",
      "446\n",
      "tensor(0.0647, grad_fn=<AddBackward0>)\n",
      "448\n",
      "tensor(0.0858, grad_fn=<AddBackward0>)\n",
      "450\n",
      "tensor(0.0628, grad_fn=<AddBackward0>)\n",
      "452\n",
      "tensor(0.0677, grad_fn=<AddBackward0>)\n",
      "454\n",
      "tensor(0.0576, grad_fn=<AddBackward0>)\n",
      "456\n",
      "tensor(0.0694, grad_fn=<AddBackward0>)\n",
      "458\n",
      "tensor(0.0626, grad_fn=<AddBackward0>)\n",
      "460\n",
      "tensor(0.0743, grad_fn=<AddBackward0>)\n",
      "462\n",
      "tensor(0.0753, grad_fn=<AddBackward0>)\n",
      "464\n",
      "tensor(0.1311, grad_fn=<AddBackward0>)\n",
      "466\n",
      "tensor(0.0594, grad_fn=<AddBackward0>)\n",
      "468\n",
      "tensor(0.0640, grad_fn=<AddBackward0>)\n",
      "470\n",
      "tensor(0.0944, grad_fn=<AddBackward0>)\n",
      "472\n",
      "tensor(0.0493, grad_fn=<AddBackward0>)\n",
      "474\n",
      "tensor(0.0812, grad_fn=<AddBackward0>)\n",
      "476\n",
      "tensor(0.0554, grad_fn=<AddBackward0>)\n",
      "478\n",
      "tensor(0.0662, grad_fn=<AddBackward0>)\n",
      "480\n",
      "tensor(0.0845, grad_fn=<AddBackward0>)\n",
      "482\n",
      "tensor(0.0825, grad_fn=<AddBackward0>)\n",
      "484\n",
      "tensor(0.0719, grad_fn=<AddBackward0>)\n",
      "486\n",
      "tensor(0.0735, grad_fn=<AddBackward0>)\n",
      "488\n",
      "tensor(0.0656, grad_fn=<AddBackward0>)\n",
      "490\n",
      "tensor(0.0890, grad_fn=<AddBackward0>)\n",
      "492\n",
      "tensor(0.0672, grad_fn=<AddBackward0>)\n",
      "494\n",
      "tensor(0.0724, grad_fn=<AddBackward0>)\n",
      "496\n",
      "tensor(0.0686, grad_fn=<AddBackward0>)\n",
      "498\n",
      "tensor(0.0376, grad_fn=<AddBackward0>)\n",
      "500\n",
      "tensor(0.0640, grad_fn=<AddBackward0>)\n",
      "502\n",
      "tensor(0.0626, grad_fn=<AddBackward0>)\n",
      "504\n",
      "tensor(0.0778, grad_fn=<AddBackward0>)\n",
      "506\n",
      "tensor(0.0651, grad_fn=<AddBackward0>)\n",
      "508\n",
      "tensor(0.0758, grad_fn=<AddBackward0>)\n",
      "510\n",
      "tensor(0.0498, grad_fn=<AddBackward0>)\n",
      "512\n",
      "tensor(0.0925, grad_fn=<AddBackward0>)\n",
      "514\n",
      "tensor(0.0884, grad_fn=<AddBackward0>)\n",
      "516\n",
      "tensor(0.0714, grad_fn=<AddBackward0>)\n",
      "518\n",
      "tensor(0.0520, grad_fn=<AddBackward0>)\n",
      "520\n",
      "tensor(0.0796, grad_fn=<AddBackward0>)\n",
      "522\n",
      "tensor(0.0548, grad_fn=<AddBackward0>)\n",
      "524\n",
      "tensor(0.0830, grad_fn=<AddBackward0>)\n",
      "526\n",
      "tensor(0.0583, grad_fn=<AddBackward0>)\n",
      "528\n",
      "tensor(0.0563, grad_fn=<AddBackward0>)\n",
      "530\n",
      "tensor(0.0733, grad_fn=<AddBackward0>)\n",
      "532\n",
      "tensor(0.0996, grad_fn=<AddBackward0>)\n",
      "534\n",
      "tensor(0.0745, grad_fn=<AddBackward0>)\n",
      "536\n",
      "tensor(0.0503, grad_fn=<AddBackward0>)\n",
      "538\n",
      "tensor(0.0804, grad_fn=<AddBackward0>)\n",
      "540\n",
      "tensor(0.0777, grad_fn=<AddBackward0>)\n",
      "542\n",
      "tensor(0.0932, grad_fn=<AddBackward0>)\n",
      "544\n",
      "tensor(0.0722, grad_fn=<AddBackward0>)\n",
      "546\n",
      "tensor(0.0994, grad_fn=<AddBackward0>)\n",
      "548\n",
      "tensor(0.0833, grad_fn=<AddBackward0>)\n",
      "550\n",
      "tensor(0.0732, grad_fn=<AddBackward0>)\n",
      "552\n",
      "tensor(0.0640, grad_fn=<AddBackward0>)\n",
      "554\n",
      "tensor(0.1006, grad_fn=<AddBackward0>)\n",
      "556\n",
      "tensor(0.0747, grad_fn=<AddBackward0>)\n",
      "558\n",
      "tensor(0.0766, grad_fn=<AddBackward0>)\n",
      "560\n",
      "tensor(0.0608, grad_fn=<AddBackward0>)\n",
      "562\n",
      "tensor(0.0665, grad_fn=<AddBackward0>)\n",
      "564\n",
      "tensor(0.0813, grad_fn=<AddBackward0>)\n",
      "566\n",
      "tensor(0.0712, grad_fn=<AddBackward0>)\n",
      "568\n",
      "tensor(0.0726, grad_fn=<AddBackward0>)\n",
      "570\n",
      "tensor(0.0748, grad_fn=<AddBackward0>)\n",
      "572\n",
      "tensor(0.0895, grad_fn=<AddBackward0>)\n",
      "574\n",
      "tensor(0.0725, grad_fn=<AddBackward0>)\n",
      "576\n",
      "tensor(0.0685, grad_fn=<AddBackward0>)\n",
      "578\n",
      "tensor(0.0719, grad_fn=<AddBackward0>)\n",
      "580\n",
      "tensor(0.0677, grad_fn=<AddBackward0>)\n",
      "582\n",
      "tensor(0.0721, grad_fn=<AddBackward0>)\n",
      "584\n",
      "tensor(0.0486, grad_fn=<AddBackward0>)\n",
      "586\n",
      "tensor(0.0718, grad_fn=<AddBackward0>)\n",
      "588\n",
      "tensor(0.0804, grad_fn=<AddBackward0>)\n",
      "590\n",
      "tensor(0.0727, grad_fn=<AddBackward0>)\n",
      "592\n",
      "tensor(0.0469, grad_fn=<AddBackward0>)\n",
      "594\n",
      "tensor(0.0929, grad_fn=<AddBackward0>)\n",
      "596\n",
      "tensor(0.0676, grad_fn=<AddBackward0>)\n",
      "598\n",
      "tensor(0.0686, grad_fn=<AddBackward0>)\n",
      "600\n",
      "tensor(0.1113, grad_fn=<AddBackward0>)\n",
      "602\n",
      "tensor(0.0691, grad_fn=<AddBackward0>)\n",
      "604\n",
      "tensor(0.0495, grad_fn=<AddBackward0>)\n",
      "606\n",
      "tensor(0.0905, grad_fn=<AddBackward0>)\n",
      "608\n",
      "tensor(0.0754, grad_fn=<AddBackward0>)\n",
      "610\n",
      "tensor(0.0665, grad_fn=<AddBackward0>)\n",
      "612\n",
      "tensor(0.0819, grad_fn=<AddBackward0>)\n",
      "614\n",
      "tensor(0.0752, grad_fn=<AddBackward0>)\n",
      "616\n",
      "tensor(0.0560, grad_fn=<AddBackward0>)\n",
      "618\n",
      "tensor(0.0818, grad_fn=<AddBackward0>)\n",
      "620\n",
      "tensor(0.0594, grad_fn=<AddBackward0>)\n",
      "622\n",
      "tensor(0.0630, grad_fn=<AddBackward0>)\n",
      "624\n",
      "tensor(0.0588, grad_fn=<AddBackward0>)\n",
      "626\n",
      "tensor(0.0605, grad_fn=<AddBackward0>)\n",
      "628\n",
      "tensor(0.0734, grad_fn=<AddBackward0>)\n",
      "630\n",
      "tensor(0.0999, grad_fn=<AddBackward0>)\n",
      "632\n",
      "tensor(0.0716, grad_fn=<AddBackward0>)\n",
      "634\n",
      "tensor(0.0667, grad_fn=<AddBackward0>)\n",
      "636\n",
      "tensor(0.0656, grad_fn=<AddBackward0>)\n",
      "638\n",
      "tensor(0.0805, grad_fn=<AddBackward0>)\n",
      "640\n",
      "tensor(0.0498, grad_fn=<AddBackward0>)\n",
      "642\n",
      "tensor(0.0650, grad_fn=<AddBackward0>)\n",
      "644\n",
      "tensor(0.0613, grad_fn=<AddBackward0>)\n",
      "646\n",
      "tensor(0.0688, grad_fn=<AddBackward0>)\n",
      "648\n",
      "tensor(0.0688, grad_fn=<AddBackward0>)\n",
      "650\n",
      "tensor(0.1016, grad_fn=<AddBackward0>)\n",
      "652\n",
      "tensor(0.0657, grad_fn=<AddBackward0>)\n",
      "654\n",
      "tensor(0.0616, grad_fn=<AddBackward0>)\n",
      "656\n",
      "tensor(0.0655, grad_fn=<AddBackward0>)\n",
      "658\n",
      "tensor(0.0516, grad_fn=<AddBackward0>)\n",
      "660\n",
      "tensor(0.0645, grad_fn=<AddBackward0>)\n",
      "662\n",
      "tensor(0.1069, grad_fn=<AddBackward0>)\n",
      "664\n",
      "tensor(0.0785, grad_fn=<AddBackward0>)\n",
      "666\n",
      "tensor(0.0849, grad_fn=<AddBackward0>)\n",
      "668\n",
      "tensor(0.0575, grad_fn=<AddBackward0>)\n",
      "670\n",
      "tensor(0.0721, grad_fn=<AddBackward0>)\n",
      "672\n",
      "tensor(0.0637, grad_fn=<AddBackward0>)\n",
      "674\n",
      "tensor(0.0569, grad_fn=<AddBackward0>)\n",
      "676\n",
      "tensor(0.0778, grad_fn=<AddBackward0>)\n",
      "678\n",
      "tensor(0.1003, grad_fn=<AddBackward0>)\n",
      "680\n",
      "tensor(0.0766, grad_fn=<AddBackward0>)\n",
      "682\n",
      "tensor(0.0896, grad_fn=<AddBackward0>)\n",
      "684\n",
      "tensor(0.0618, grad_fn=<AddBackward0>)\n",
      "686\n",
      "tensor(0.0642, grad_fn=<AddBackward0>)\n",
      "688\n",
      "tensor(0.0828, grad_fn=<AddBackward0>)\n",
      "690\n",
      "tensor(0.0735, grad_fn=<AddBackward0>)\n",
      "692\n",
      "tensor(0.0635, grad_fn=<AddBackward0>)\n",
      "694\n",
      "tensor(0.0710, grad_fn=<AddBackward0>)\n",
      "696\n",
      "tensor(0.0643, grad_fn=<AddBackward0>)\n",
      "698\n",
      "tensor(0.0702, grad_fn=<AddBackward0>)\n",
      "700\n",
      "tensor(0.0758, grad_fn=<AddBackward0>)\n",
      "702\n",
      "tensor(0.0789, grad_fn=<AddBackward0>)\n",
      "704\n",
      "tensor(0.0837, grad_fn=<AddBackward0>)\n",
      "706\n",
      "tensor(0.0671, grad_fn=<AddBackward0>)\n",
      "708\n",
      "tensor(0.0997, grad_fn=<AddBackward0>)\n",
      "710\n",
      "tensor(0.0788, grad_fn=<AddBackward0>)\n",
      "712\n",
      "tensor(0.0650, grad_fn=<AddBackward0>)\n",
      "714\n",
      "tensor(0.0831, grad_fn=<AddBackward0>)\n",
      "716\n",
      "tensor(0.0643, grad_fn=<AddBackward0>)\n",
      "718\n",
      "tensor(0.0619, grad_fn=<AddBackward0>)\n",
      "720\n",
      "tensor(0.0722, grad_fn=<AddBackward0>)\n",
      "722\n",
      "tensor(0.0988, grad_fn=<AddBackward0>)\n",
      "724\n",
      "tensor(0.0841, grad_fn=<AddBackward0>)\n",
      "726\n",
      "tensor(0.0931, grad_fn=<AddBackward0>)\n",
      "728\n",
      "tensor(0.0411, grad_fn=<AddBackward0>)\n",
      "730\n",
      "tensor(0.0627, grad_fn=<AddBackward0>)\n",
      "732\n",
      "tensor(0.0645, grad_fn=<AddBackward0>)\n",
      "734\n",
      "tensor(0.0401, grad_fn=<AddBackward0>)\n",
      "736\n",
      "tensor(0.0837, grad_fn=<AddBackward0>)\n",
      "738\n",
      "tensor(0.0811, grad_fn=<AddBackward0>)\n",
      "740\n",
      "tensor(0.0778, grad_fn=<AddBackward0>)\n",
      "742\n",
      "tensor(0.0113, grad_fn=<AddBackward0>)\n",
      "744\n",
      "tensor(0.0569, grad_fn=<AddBackward0>)\n",
      "746\n",
      "tensor(0.0737, grad_fn=<AddBackward0>)\n",
      "748\n",
      "tensor(0.0757, grad_fn=<AddBackward0>)\n",
      "750\n",
      "tensor(0.0818, grad_fn=<AddBackward0>)\n",
      "752\n",
      "tensor(0.0836, grad_fn=<AddBackward0>)\n",
      "754\n",
      "tensor(0.0685, grad_fn=<AddBackward0>)\n",
      "756\n",
      "tensor(0.0878, grad_fn=<AddBackward0>)\n",
      "758\n",
      "tensor(0.0213, grad_fn=<AddBackward0>)\n",
      "760\n",
      "tensor(0.0617, grad_fn=<AddBackward0>)\n",
      "762\n",
      "tensor(0.0522, grad_fn=<AddBackward0>)\n",
      "764\n",
      "tensor(0.0825, grad_fn=<AddBackward0>)\n",
      "766\n",
      "tensor(0.0828, grad_fn=<AddBackward0>)\n",
      "768\n",
      "tensor(0.0733, grad_fn=<AddBackward0>)\n",
      "770\n",
      "tensor(0.0653, grad_fn=<AddBackward0>)\n",
      "772\n",
      "tensor(0.0707, grad_fn=<AddBackward0>)\n",
      "774\n",
      "tensor(0.0827, grad_fn=<AddBackward0>)\n",
      "776\n",
      "tensor(0.0752, grad_fn=<AddBackward0>)\n",
      "778\n",
      "tensor(0.0811, grad_fn=<AddBackward0>)\n",
      "780\n",
      "tensor(0.1055, grad_fn=<AddBackward0>)\n",
      "782\n",
      "tensor(0.0679, grad_fn=<AddBackward0>)\n",
      "784\n",
      "tensor(0.0691, grad_fn=<AddBackward0>)\n",
      "786\n",
      "tensor(0.0618, grad_fn=<AddBackward0>)\n",
      "788\n",
      "tensor(0.0576, grad_fn=<AddBackward0>)\n",
      "790\n",
      "tensor(0.0896, grad_fn=<AddBackward0>)\n",
      "792\n",
      "tensor(0.0670, grad_fn=<AddBackward0>)\n",
      "794\n",
      "tensor(0.0258, grad_fn=<AddBackward0>)\n",
      "796\n",
      "tensor(0.0898, grad_fn=<AddBackward0>)\n",
      "798\n",
      "tensor(0.0532, grad_fn=<AddBackward0>)\n",
      "800\n",
      "tensor(0.0820, grad_fn=<AddBackward0>)\n",
      "802\n",
      "tensor(0.0720, grad_fn=<AddBackward0>)\n",
      "804\n",
      "tensor(0.0723, grad_fn=<AddBackward0>)\n",
      "806\n",
      "tensor(0.0993, grad_fn=<AddBackward0>)\n",
      "808\n",
      "tensor(0.0722, grad_fn=<AddBackward0>)\n",
      "810\n",
      "tensor(0.0710, grad_fn=<AddBackward0>)\n",
      "812\n",
      "tensor(0.0625, grad_fn=<AddBackward0>)\n",
      "814\n",
      "tensor(0.1006, grad_fn=<AddBackward0>)\n",
      "816\n",
      "tensor(0.0794, grad_fn=<AddBackward0>)\n",
      "818\n",
      "tensor(0.0820, grad_fn=<AddBackward0>)\n",
      "820\n",
      "tensor(0.0704, grad_fn=<AddBackward0>)\n",
      "822\n",
      "tensor(0.0777, grad_fn=<AddBackward0>)\n",
      "824\n",
      "tensor(0.0577, grad_fn=<AddBackward0>)\n",
      "826\n",
      "tensor(0.0866, grad_fn=<AddBackward0>)\n",
      "828\n",
      "tensor(0.0655, grad_fn=<AddBackward0>)\n",
      "830\n",
      "tensor(0.0831, grad_fn=<AddBackward0>)\n",
      "832\n",
      "tensor(0.0668, grad_fn=<AddBackward0>)\n",
      "834\n",
      "tensor(0.0859, grad_fn=<AddBackward0>)\n",
      "836\n",
      "tensor(0.0711, grad_fn=<AddBackward0>)\n",
      "838\n",
      "tensor(0.0599, grad_fn=<AddBackward0>)\n",
      "840\n",
      "tensor(0.0772, grad_fn=<AddBackward0>)\n",
      "842\n",
      "tensor(0.0632, grad_fn=<AddBackward0>)\n",
      "844\n",
      "tensor(0.0889, grad_fn=<AddBackward0>)\n",
      "846\n",
      "tensor(0.0730, grad_fn=<AddBackward0>)\n",
      "848\n",
      "tensor(0.0621, grad_fn=<AddBackward0>)\n",
      "850\n",
      "tensor(0.0755, grad_fn=<AddBackward0>)\n",
      "852\n",
      "tensor(0.0642, grad_fn=<AddBackward0>)\n",
      "854\n",
      "tensor(0.0806, grad_fn=<AddBackward0>)\n",
      "856\n",
      "tensor(0.0828, grad_fn=<AddBackward0>)\n",
      "858\n",
      "tensor(0.1003, grad_fn=<AddBackward0>)\n",
      "860\n",
      "tensor(0.0420, grad_fn=<AddBackward0>)\n",
      "862\n",
      "tensor(0.0839, grad_fn=<AddBackward0>)\n",
      "864\n",
      "tensor(0.0568, grad_fn=<AddBackward0>)\n",
      "866\n",
      "tensor(0.0749, grad_fn=<AddBackward0>)\n",
      "868\n",
      "tensor(0.0719, grad_fn=<AddBackward0>)\n",
      "870\n",
      "tensor(0.0619, grad_fn=<AddBackward0>)\n",
      "872\n",
      "tensor(0.0757, grad_fn=<AddBackward0>)\n",
      "874\n",
      "tensor(0.1027, grad_fn=<AddBackward0>)\n",
      "876\n",
      "tensor(0.0560, grad_fn=<AddBackward0>)\n",
      "878\n",
      "tensor(0.0638, grad_fn=<AddBackward0>)\n",
      "880\n",
      "tensor(0.0775, grad_fn=<AddBackward0>)\n",
      "882\n",
      "tensor(0.0627, grad_fn=<AddBackward0>)\n",
      "884\n",
      "tensor(0.0657, grad_fn=<AddBackward0>)\n",
      "886\n",
      "tensor(0.0785, grad_fn=<AddBackward0>)\n",
      "888\n",
      "tensor(0.0770, grad_fn=<AddBackward0>)\n",
      "890\n",
      "tensor(0.0755, grad_fn=<AddBackward0>)\n",
      "892\n",
      "tensor(0.0622, grad_fn=<AddBackward0>)\n",
      "894\n",
      "tensor(0.0585, grad_fn=<AddBackward0>)\n",
      "896\n",
      "tensor(0.0920, grad_fn=<AddBackward0>)\n",
      "898\n",
      "tensor(0.0611, grad_fn=<AddBackward0>)\n",
      "900\n",
      "tensor(0.0353, grad_fn=<AddBackward0>)\n",
      "902\n",
      "tensor(0.0585, grad_fn=<AddBackward0>)\n",
      "904\n",
      "tensor(0.0681, grad_fn=<AddBackward0>)\n",
      "906\n",
      "tensor(0.1052, grad_fn=<AddBackward0>)\n",
      "908\n",
      "tensor(0.0478, grad_fn=<AddBackward0>)\n",
      "910\n",
      "tensor(0.0840, grad_fn=<AddBackward0>)\n",
      "912\n",
      "tensor(0.0739, grad_fn=<AddBackward0>)\n",
      "914\n",
      "tensor(0.0942, grad_fn=<AddBackward0>)\n",
      "916\n",
      "tensor(0.0569, grad_fn=<AddBackward0>)\n",
      "918\n",
      "tensor(0.0597, grad_fn=<AddBackward0>)\n",
      "920\n",
      "tensor(0.0594, grad_fn=<AddBackward0>)\n",
      "922\n",
      "tensor(0.0768, grad_fn=<AddBackward0>)\n",
      "924\n",
      "tensor(0.0811, grad_fn=<AddBackward0>)\n",
      "926\n",
      "tensor(0.0596, grad_fn=<AddBackward0>)\n",
      "928\n",
      "tensor(0.0336, grad_fn=<AddBackward0>)\n",
      "930\n",
      "tensor(0.0769, grad_fn=<AddBackward0>)\n",
      "932\n",
      "tensor(0.0830, grad_fn=<AddBackward0>)\n",
      "934\n",
      "tensor(0.0595, grad_fn=<AddBackward0>)\n",
      "936\n",
      "tensor(0.0790, grad_fn=<AddBackward0>)\n",
      "938\n",
      "tensor(0.0800, grad_fn=<AddBackward0>)\n",
      "940\n",
      "tensor(0.0493, grad_fn=<AddBackward0>)\n",
      "942\n",
      "tensor(0.0758, grad_fn=<AddBackward0>)\n",
      "944\n",
      "tensor(0.0583, grad_fn=<AddBackward0>)\n",
      "946\n",
      "tensor(0.1032, grad_fn=<AddBackward0>)\n",
      "948\n",
      "tensor(0.0649, grad_fn=<AddBackward0>)\n",
      "950\n",
      "tensor(0.0626, grad_fn=<AddBackward0>)\n",
      "952\n",
      "tensor(0.0703, grad_fn=<AddBackward0>)\n",
      "954\n",
      "tensor(0.0766, grad_fn=<AddBackward0>)\n",
      "956\n",
      "tensor(0.0640, grad_fn=<AddBackward0>)\n",
      "958\n",
      "tensor(0.0894, grad_fn=<AddBackward0>)\n",
      "960\n",
      "tensor(0.0930, grad_fn=<AddBackward0>)\n",
      "962\n",
      "tensor(0.0628, grad_fn=<AddBackward0>)\n",
      "964\n",
      "tensor(0.0871, grad_fn=<AddBackward0>)\n",
      "966\n",
      "tensor(0.0699, grad_fn=<AddBackward0>)\n",
      "968\n",
      "tensor(0.0688, grad_fn=<AddBackward0>)\n",
      "970\n",
      "tensor(0.1057, grad_fn=<AddBackward0>)\n",
      "972\n",
      "tensor(0.0567, grad_fn=<AddBackward0>)\n",
      "974\n",
      "tensor(0.1036, grad_fn=<AddBackward0>)\n",
      "976\n",
      "tensor(0.0746, grad_fn=<AddBackward0>)\n",
      "978\n",
      "tensor(0.0550, grad_fn=<AddBackward0>)\n",
      "980\n",
      "tensor(0.0520, grad_fn=<AddBackward0>)\n",
      "982\n",
      "tensor(0.0662, grad_fn=<AddBackward0>)\n",
      "984\n",
      "tensor(0.0764, grad_fn=<AddBackward0>)\n",
      "986\n",
      "tensor(0.0801, grad_fn=<AddBackward0>)\n",
      "988\n",
      "tensor(0.1170, grad_fn=<AddBackward0>)\n",
      "990\n",
      "tensor(0.0763, grad_fn=<AddBackward0>)\n",
      "992\n",
      "tensor(0.0725, grad_fn=<AddBackward0>)\n",
      "994\n",
      "tensor(0.0742, grad_fn=<AddBackward0>)\n",
      "996\n",
      "tensor(0.0844, grad_fn=<AddBackward0>)\n",
      "998\n",
      "tensor(0.0608, grad_fn=<AddBackward0>)\n",
      "1000\n",
      "tensor(0.0527, grad_fn=<AddBackward0>)\n",
      "1002\n",
      "tensor(0.0850, grad_fn=<AddBackward0>)\n",
      "1004\n",
      "tensor(0.0760, grad_fn=<AddBackward0>)\n",
      "1006\n",
      "tensor(0.0021, grad_fn=<AddBackward0>)\n",
      "1008\n",
      "tensor(0.0466, grad_fn=<AddBackward0>)\n",
      "1010\n",
      "tensor(0.0859, grad_fn=<AddBackward0>)\n",
      "1012\n",
      "tensor(0.0717, grad_fn=<AddBackward0>)\n",
      "1014\n",
      "tensor(0.0542, grad_fn=<AddBackward0>)\n",
      "1016\n",
      "tensor(0.0953, grad_fn=<AddBackward0>)\n",
      "1018\n",
      "tensor(0.0827, grad_fn=<AddBackward0>)\n",
      "1020\n",
      "tensor(0.0957, grad_fn=<AddBackward0>)\n",
      "1022\n",
      "tensor(0.0694, grad_fn=<AddBackward0>)\n",
      "1024\n",
      "tensor(0.0697, grad_fn=<AddBackward0>)\n",
      "1026\n",
      "tensor(0.0700, grad_fn=<AddBackward0>)\n",
      "1028\n",
      "tensor(0.0726, grad_fn=<AddBackward0>)\n",
      "1030\n",
      "tensor(0.0755, grad_fn=<AddBackward0>)\n",
      "1032\n",
      "tensor(0.1115, grad_fn=<AddBackward0>)\n",
      "1034\n",
      "tensor(0.0768, grad_fn=<AddBackward0>)\n",
      "1036\n",
      "tensor(0.0944, grad_fn=<AddBackward0>)\n",
      "1038\n",
      "tensor(0.0677, grad_fn=<AddBackward0>)\n",
      "1040\n",
      "tensor(0.0581, grad_fn=<AddBackward0>)\n",
      "1042\n",
      "tensor(0.0815, grad_fn=<AddBackward0>)\n",
      "1044\n",
      "tensor(0.0834, grad_fn=<AddBackward0>)\n",
      "1046\n",
      "tensor(0.0565, grad_fn=<AddBackward0>)\n",
      "1048\n",
      "tensor(0.0724, grad_fn=<AddBackward0>)\n",
      "1050\n",
      "tensor(0.0695, grad_fn=<AddBackward0>)\n",
      "1052\n",
      "tensor(0.0489, grad_fn=<AddBackward0>)\n",
      "1054\n",
      "tensor(0.0665, grad_fn=<AddBackward0>)\n",
      "1056\n",
      "tensor(0.0857, grad_fn=<AddBackward0>)\n",
      "1058\n",
      "tensor(0.0763, grad_fn=<AddBackward0>)\n",
      "1060\n",
      "tensor(0.0648, grad_fn=<AddBackward0>)\n",
      "1062\n",
      "tensor(0.0788, grad_fn=<AddBackward0>)\n",
      "1064\n",
      "tensor(0.0687, grad_fn=<AddBackward0>)\n",
      "1066\n",
      "tensor(0.0848, grad_fn=<AddBackward0>)\n",
      "1068\n",
      "tensor(0.1073, grad_fn=<AddBackward0>)\n",
      "1070\n",
      "tensor(0.0752, grad_fn=<AddBackward0>)\n",
      "1072\n",
      "tensor(0.0751, grad_fn=<AddBackward0>)\n",
      "1074\n",
      "tensor(0.1019, grad_fn=<AddBackward0>)\n",
      "1076\n",
      "tensor(0.0710, grad_fn=<AddBackward0>)\n",
      "1078\n",
      "tensor(0.0684, grad_fn=<AddBackward0>)\n",
      "1080\n",
      "tensor(0.0875, grad_fn=<AddBackward0>)\n",
      "1082\n",
      "tensor(0.0591, grad_fn=<AddBackward0>)\n",
      "1084\n",
      "tensor(0.0612, grad_fn=<AddBackward0>)\n",
      "1086\n",
      "tensor(0.0819, grad_fn=<AddBackward0>)\n",
      "1088\n",
      "tensor(0.0617, grad_fn=<AddBackward0>)\n",
      "1090\n",
      "tensor(0.0564, grad_fn=<AddBackward0>)\n",
      "1092\n",
      "tensor(0.1009, grad_fn=<AddBackward0>)\n",
      "1094\n",
      "tensor(0.0821, grad_fn=<AddBackward0>)\n",
      "1096\n",
      "tensor(0.0814, grad_fn=<AddBackward0>)\n",
      "1098\n",
      "tensor(0.0765, grad_fn=<AddBackward0>)\n",
      "1100\n",
      "tensor(0.0733, grad_fn=<AddBackward0>)\n",
      "1102\n",
      "tensor(0.0696, grad_fn=<AddBackward0>)\n",
      "1104\n",
      "tensor(0.0850, grad_fn=<AddBackward0>)\n",
      "1106\n",
      "tensor(0.0704, grad_fn=<AddBackward0>)\n",
      "1108\n",
      "tensor(0.0874, grad_fn=<AddBackward0>)\n",
      "1110\n",
      "tensor(0.0916, grad_fn=<AddBackward0>)\n",
      "1112\n",
      "tensor(0.0828, grad_fn=<AddBackward0>)\n",
      "1114\n",
      "tensor(0.1195, grad_fn=<AddBackward0>)\n",
      "1116\n",
      "tensor(0.0699, grad_fn=<AddBackward0>)\n",
      "1118\n",
      "tensor(0.0617, grad_fn=<AddBackward0>)\n",
      "1120\n",
      "tensor(0.0641, grad_fn=<AddBackward0>)\n",
      "1122\n",
      "tensor(0.0659, grad_fn=<AddBackward0>)\n",
      "1124\n",
      "tensor(0.0746, grad_fn=<AddBackward0>)\n",
      "1126\n",
      "tensor(0.0315, grad_fn=<AddBackward0>)\n",
      "1128\n",
      "tensor(0.0714, grad_fn=<AddBackward0>)\n",
      "1130\n",
      "tensor(0.0795, grad_fn=<AddBackward0>)\n",
      "1132\n",
      "tensor(0.0656, grad_fn=<AddBackward0>)\n",
      "1134\n",
      "tensor(0.0841, grad_fn=<AddBackward0>)\n",
      "1136\n",
      "tensor(0.0760, grad_fn=<AddBackward0>)\n",
      "1138\n",
      "tensor(0.0787, grad_fn=<AddBackward0>)\n",
      "1140\n",
      "tensor(0.0823, grad_fn=<AddBackward0>)\n",
      "1142\n",
      "tensor(0.0699, grad_fn=<AddBackward0>)\n",
      "1144\n",
      "tensor(0.0627, grad_fn=<AddBackward0>)\n",
      "1146\n",
      "tensor(0.0733, grad_fn=<AddBackward0>)\n",
      "1148\n",
      "tensor(0.0499, grad_fn=<AddBackward0>)\n",
      "1150\n",
      "tensor(0.0634, grad_fn=<AddBackward0>)\n",
      "1152\n",
      "tensor(0.0678, grad_fn=<AddBackward0>)\n",
      "1154\n",
      "tensor(0.0680, grad_fn=<AddBackward0>)\n",
      "1156\n",
      "tensor(0.0964, grad_fn=<AddBackward0>)\n",
      "1158\n",
      "tensor(0.0785, grad_fn=<AddBackward0>)\n",
      "1160\n",
      "tensor(0.0805, grad_fn=<AddBackward0>)\n",
      "1162\n",
      "tensor(0.0662, grad_fn=<AddBackward0>)\n",
      "1164\n",
      "tensor(0.0810, grad_fn=<AddBackward0>)\n",
      "1166\n",
      "tensor(0.0750, grad_fn=<AddBackward0>)\n",
      "1168\n",
      "tensor(0.0739, grad_fn=<AddBackward0>)\n",
      "1170\n",
      "tensor(0.0642, grad_fn=<AddBackward0>)\n",
      "1172\n",
      "tensor(0.0646, grad_fn=<AddBackward0>)\n",
      "1174\n",
      "tensor(0.0687, grad_fn=<AddBackward0>)\n",
      "1176\n",
      "tensor(0.0868, grad_fn=<AddBackward0>)\n",
      "1178\n",
      "tensor(0.0729, grad_fn=<AddBackward0>)\n",
      "1180\n",
      "tensor(0.0825, grad_fn=<AddBackward0>)\n",
      "1182\n",
      "tensor(0.0630, grad_fn=<AddBackward0>)\n",
      "1184\n",
      "tensor(0.0374, grad_fn=<AddBackward0>)\n",
      "1186\n",
      "tensor(0.0596, grad_fn=<AddBackward0>)\n",
      "1188\n",
      "tensor(0.0041, grad_fn=<AddBackward0>)\n",
      "1190\n",
      "tensor(0.0708, grad_fn=<AddBackward0>)\n",
      "1192\n",
      "tensor(0.0729, grad_fn=<AddBackward0>)\n",
      "1194\n",
      "tensor(0.0672, grad_fn=<AddBackward0>)\n",
      "1196\n",
      "tensor(0.0783, grad_fn=<AddBackward0>)\n",
      "1198\n",
      "tensor(0.0801, grad_fn=<AddBackward0>)\n",
      "1200\n",
      "tensor(0.0685, grad_fn=<AddBackward0>)\n",
      "1202\n",
      "tensor(0.0560, grad_fn=<AddBackward0>)\n",
      "1204\n",
      "tensor(0.0747, grad_fn=<AddBackward0>)\n",
      "1206\n",
      "tensor(0.0684, grad_fn=<AddBackward0>)\n",
      "1208\n",
      "tensor(0.0642, grad_fn=<AddBackward0>)\n",
      "1210\n",
      "tensor(0.0792, grad_fn=<AddBackward0>)\n",
      "1212\n",
      "tensor(0.1052, grad_fn=<AddBackward0>)\n",
      "1214\n",
      "tensor(0.0651, grad_fn=<AddBackward0>)\n",
      "1216\n",
      "tensor(0.0865, grad_fn=<AddBackward0>)\n",
      "1218\n",
      "tensor(0.0566, grad_fn=<AddBackward0>)\n",
      "1220\n",
      "tensor(0.0736, grad_fn=<AddBackward0>)\n",
      "1222\n",
      "tensor(0.0828, grad_fn=<AddBackward0>)\n",
      "1224\n",
      "tensor(0.0645, grad_fn=<AddBackward0>)\n",
      "1226\n",
      "tensor(0.0669, grad_fn=<AddBackward0>)\n",
      "1228\n",
      "tensor(0.0680, grad_fn=<AddBackward0>)\n",
      "1230\n",
      "tensor(0.0664, grad_fn=<AddBackward0>)\n",
      "1232\n",
      "tensor(0.0865, grad_fn=<AddBackward0>)\n",
      "1234\n",
      "tensor(0.0830, grad_fn=<AddBackward0>)\n",
      "1236\n",
      "tensor(0.0926, grad_fn=<AddBackward0>)\n",
      "1238\n",
      "tensor(0.0645, grad_fn=<AddBackward0>)\n",
      "1240\n",
      "tensor(0.0661, grad_fn=<AddBackward0>)\n",
      "1242\n",
      "tensor(0.0756, grad_fn=<AddBackward0>)\n",
      "1244\n",
      "tensor(0.0930, grad_fn=<AddBackward0>)\n",
      "1246\n",
      "tensor(0.0733, grad_fn=<AddBackward0>)\n",
      "1248\n",
      "tensor(0.0606, grad_fn=<AddBackward0>)\n",
      "1250\n",
      "tensor(0.0595, grad_fn=<AddBackward0>)\n",
      "1252\n",
      "tensor(0.0737, grad_fn=<AddBackward0>)\n",
      "1254\n",
      "tensor(0.0651, grad_fn=<AddBackward0>)\n",
      "1256\n",
      "tensor(0.0802, grad_fn=<AddBackward0>)\n",
      "1258\n",
      "tensor(0.0530, grad_fn=<AddBackward0>)\n",
      "1260\n",
      "tensor(0.0833, grad_fn=<AddBackward0>)\n",
      "1262\n",
      "tensor(0.0634, grad_fn=<AddBackward0>)\n",
      "1264\n",
      "tensor(0.0766, grad_fn=<AddBackward0>)\n",
      "1266\n",
      "tensor(0.0912, grad_fn=<AddBackward0>)\n",
      "1268\n",
      "tensor(0.0751, grad_fn=<AddBackward0>)\n",
      "1270\n",
      "tensor(0.0666, grad_fn=<AddBackward0>)\n",
      "1272\n",
      "tensor(0.0746, grad_fn=<AddBackward0>)\n",
      "1274\n",
      "tensor(0.0785, grad_fn=<AddBackward0>)\n",
      "1276\n",
      "tensor(0.0847, grad_fn=<AddBackward0>)\n",
      "1278\n",
      "tensor(0.0726, grad_fn=<AddBackward0>)\n",
      "1280\n",
      "tensor(0.2208, grad_fn=<AddBackward0>)\n",
      "1282\n",
      "tensor(0.0455, grad_fn=<AddBackward0>)\n",
      "1284\n",
      "tensor(0.0629, grad_fn=<AddBackward0>)\n",
      "1286\n",
      "tensor(0.0684, grad_fn=<AddBackward0>)\n",
      "1288\n",
      "tensor(0.0768, grad_fn=<AddBackward0>)\n",
      "1290\n",
      "tensor(0.0643, grad_fn=<AddBackward0>)\n",
      "1292\n",
      "tensor(0.0626, grad_fn=<AddBackward0>)\n",
      "1294\n",
      "tensor(0.0650, grad_fn=<AddBackward0>)\n",
      "1296\n",
      "tensor(0.0717, grad_fn=<AddBackward0>)\n",
      "1298\n",
      "tensor(0.0708, grad_fn=<AddBackward0>)\n",
      "1300\n",
      "tensor(0.0734, grad_fn=<AddBackward0>)\n",
      "1302\n",
      "tensor(0.0700, grad_fn=<AddBackward0>)\n",
      "1304\n",
      "tensor(0.0561, grad_fn=<AddBackward0>)\n",
      "1306\n",
      "tensor(0.0673, grad_fn=<AddBackward0>)\n",
      "1308\n",
      "tensor(0.0647, grad_fn=<AddBackward0>)\n",
      "1310\n",
      "tensor(0.0581, grad_fn=<AddBackward0>)\n",
      "1312\n",
      "tensor(0.0628, grad_fn=<AddBackward0>)\n",
      "1314\n",
      "tensor(0.0627, grad_fn=<AddBackward0>)\n",
      "1316\n",
      "tensor(0.0663, grad_fn=<AddBackward0>)\n",
      "1318\n",
      "tensor(0.0638, grad_fn=<AddBackward0>)\n",
      "1320\n",
      "tensor(0.0845, grad_fn=<AddBackward0>)\n",
      "1322\n",
      "tensor(0.0754, grad_fn=<AddBackward0>)\n",
      "1324\n",
      "tensor(0.1366, grad_fn=<AddBackward0>)\n",
      "1326\n",
      "tensor(0.0772, grad_fn=<AddBackward0>)\n",
      "1328\n",
      "tensor(0.0615, grad_fn=<AddBackward0>)\n",
      "1330\n",
      "tensor(0.0742, grad_fn=<AddBackward0>)\n",
      "1332\n",
      "tensor(0.0902, grad_fn=<AddBackward0>)\n",
      "1334\n",
      "tensor(0.0702, grad_fn=<AddBackward0>)\n",
      "1336\n",
      "tensor(0.0662, grad_fn=<AddBackward0>)\n",
      "1338\n",
      "tensor(0.0707, grad_fn=<AddBackward0>)\n",
      "1340\n",
      "tensor(0.0912, grad_fn=<AddBackward0>)\n",
      "1342\n",
      "tensor(0.0683, grad_fn=<AddBackward0>)\n",
      "1344\n",
      "tensor(0.0849, grad_fn=<AddBackward0>)\n",
      "1346\n",
      "tensor(0.1191, grad_fn=<AddBackward0>)\n",
      "1348\n",
      "tensor(0.0713, grad_fn=<AddBackward0>)\n",
      "1350\n",
      "tensor(0.0527, grad_fn=<AddBackward0>)\n",
      "1352\n",
      "tensor(0.0823, grad_fn=<AddBackward0>)\n",
      "1354\n",
      "tensor(0.0631, grad_fn=<AddBackward0>)\n",
      "1356\n",
      "tensor(0.0842, grad_fn=<AddBackward0>)\n",
      "1358\n",
      "tensor(0.0849, grad_fn=<AddBackward0>)\n",
      "1360\n",
      "tensor(0.0301, grad_fn=<AddBackward0>)\n",
      "1362\n",
      "tensor(0.0671, grad_fn=<AddBackward0>)\n",
      "1364\n",
      "tensor(0.0876, grad_fn=<AddBackward0>)\n",
      "1366\n",
      "tensor(0.0938, grad_fn=<AddBackward0>)\n",
      "1368\n",
      "tensor(0.0698, grad_fn=<AddBackward0>)\n",
      "1370\n",
      "tensor(0.0842, grad_fn=<AddBackward0>)\n",
      "1372\n",
      "tensor(0.0565, grad_fn=<AddBackward0>)\n",
      "1374\n",
      "tensor(0.1025, grad_fn=<AddBackward0>)\n",
      "1376\n",
      "tensor(0.0689, grad_fn=<AddBackward0>)\n",
      "1378\n",
      "tensor(0.0707, grad_fn=<AddBackward0>)\n",
      "1380\n",
      "tensor(0.0703, grad_fn=<AddBackward0>)\n",
      "1382\n",
      "tensor(0.0628, grad_fn=<AddBackward0>)\n",
      "1384\n",
      "tensor(0.0757, grad_fn=<AddBackward0>)\n",
      "1386\n",
      "tensor(0.0659, grad_fn=<AddBackward0>)\n",
      "1388\n",
      "tensor(0.0785, grad_fn=<AddBackward0>)\n",
      "1390\n",
      "tensor(0.0563, grad_fn=<AddBackward0>)\n",
      "1392\n",
      "tensor(0.0918, grad_fn=<AddBackward0>)\n",
      "1394\n",
      "tensor(0.0868, grad_fn=<AddBackward0>)\n",
      "1396\n",
      "tensor(0.0736, grad_fn=<AddBackward0>)\n",
      "1398\n",
      "tensor(0.0542, grad_fn=<AddBackward0>)\n",
      "1400\n",
      "tensor(0.0701, grad_fn=<AddBackward0>)\n",
      "1402\n",
      "tensor(0.0437, grad_fn=<AddBackward0>)\n",
      "1404\n",
      "tensor(0.0011, grad_fn=<AddBackward0>)\n",
      "1406\n",
      "tensor(0.0671, grad_fn=<AddBackward0>)\n",
      "1408\n",
      "tensor(0.0738, grad_fn=<AddBackward0>)\n",
      "1410\n",
      "tensor(0.0762, grad_fn=<AddBackward0>)\n",
      "1412\n",
      "tensor(0.0757, grad_fn=<AddBackward0>)\n",
      "1414\n",
      "tensor(0.0683, grad_fn=<AddBackward0>)\n",
      "1416\n",
      "tensor(0.0806, grad_fn=<AddBackward0>)\n",
      "1418\n",
      "tensor(0.0804, grad_fn=<AddBackward0>)\n",
      "1420\n",
      "tensor(0.0954, grad_fn=<AddBackward0>)\n",
      "1422\n",
      "tensor(0.0899, grad_fn=<AddBackward0>)\n",
      "1424\n",
      "tensor(0.0568, grad_fn=<AddBackward0>)\n",
      "1426\n",
      "tensor(0.0705, grad_fn=<AddBackward0>)\n",
      "1428\n",
      "tensor(0.1019, grad_fn=<AddBackward0>)\n",
      "1430\n",
      "tensor(0.0833, grad_fn=<AddBackward0>)\n",
      "1432\n",
      "tensor(0.0692, grad_fn=<AddBackward0>)\n",
      "1434\n",
      "tensor(0.0636, grad_fn=<AddBackward0>)\n",
      "1436\n",
      "tensor(0.0587, grad_fn=<AddBackward0>)\n",
      "1438\n",
      "tensor(0.0623, grad_fn=<AddBackward0>)\n",
      "1440\n",
      "tensor(0.0736, grad_fn=<AddBackward0>)\n",
      "1442\n",
      "tensor(0.0863, grad_fn=<AddBackward0>)\n",
      "1444\n",
      "tensor(0.0890, grad_fn=<AddBackward0>)\n",
      "1446\n",
      "tensor(0.0828, grad_fn=<AddBackward0>)\n",
      "1448\n",
      "tensor(0.0834, grad_fn=<AddBackward0>)\n",
      "1450\n",
      "tensor(0.0546, grad_fn=<AddBackward0>)\n",
      "1452\n",
      "tensor(0.0625, grad_fn=<AddBackward0>)\n",
      "1454\n",
      "tensor(0.0834, grad_fn=<AddBackward0>)\n",
      "1456\n",
      "tensor(0.0803, grad_fn=<AddBackward0>)\n",
      "1458\n",
      "tensor(0.0655, grad_fn=<AddBackward0>)\n",
      "1460\n",
      "tensor(0.0679, grad_fn=<AddBackward0>)\n",
      "1462\n",
      "tensor(0.0820, grad_fn=<AddBackward0>)\n",
      "1464\n",
      "tensor(0.1025, grad_fn=<AddBackward0>)\n",
      "1466\n",
      "tensor(0.0845, grad_fn=<AddBackward0>)\n",
      "1468\n",
      "tensor(0.0749, grad_fn=<AddBackward0>)\n",
      "1470\n",
      "tensor(0.0771, grad_fn=<AddBackward0>)\n",
      "1472\n",
      "tensor(0.0757, grad_fn=<AddBackward0>)\n",
      "1474\n",
      "tensor(0.0802, grad_fn=<AddBackward0>)\n",
      "1476\n",
      "tensor(0.0955, grad_fn=<AddBackward0>)\n",
      "1478\n",
      "tensor(0.0724, grad_fn=<AddBackward0>)\n",
      "1480\n",
      "tensor(0.0650, grad_fn=<AddBackward0>)\n",
      "1482\n",
      "tensor(0.0708, grad_fn=<AddBackward0>)\n",
      "1484\n",
      "tensor(0.0569, grad_fn=<AddBackward0>)\n",
      "1486\n",
      "tensor(0.0701, grad_fn=<AddBackward0>)\n",
      "1488\n",
      "tensor(0.1004, grad_fn=<AddBackward0>)\n",
      "1490\n",
      "tensor(0.0728, grad_fn=<AddBackward0>)\n",
      "1492\n",
      "tensor(0.0705, grad_fn=<AddBackward0>)\n",
      "1494\n",
      "tensor(0.0602, grad_fn=<AddBackward0>)\n",
      "1496\n",
      "tensor(0.1010, grad_fn=<AddBackward0>)\n",
      "1498\n",
      "tensor(0.0898, grad_fn=<AddBackward0>)\n",
      "1500\n",
      "tensor(0.0823, grad_fn=<AddBackward0>)\n",
      "1502\n",
      "tensor(0.0634, grad_fn=<AddBackward0>)\n",
      "1504\n",
      "tensor(0.0743, grad_fn=<AddBackward0>)\n",
      "1506\n",
      "tensor(0.0750, grad_fn=<AddBackward0>)\n",
      "1508\n",
      "tensor(0.0584, grad_fn=<AddBackward0>)\n",
      "1510\n",
      "tensor(0.0583, grad_fn=<AddBackward0>)\n",
      "1512\n",
      "tensor(0.0695, grad_fn=<AddBackward0>)\n",
      "1514\n",
      "tensor(0.0561, grad_fn=<AddBackward0>)\n",
      "1516\n",
      "tensor(0.0750, grad_fn=<AddBackward0>)\n",
      "1518\n",
      "tensor(0.0723, grad_fn=<AddBackward0>)\n",
      "1520\n",
      "tensor(0.1107, grad_fn=<AddBackward0>)\n",
      "1522\n",
      "tensor(0.0746, grad_fn=<AddBackward0>)\n",
      "1524\n",
      "tensor(0.0433, grad_fn=<AddBackward0>)\n",
      "1526\n",
      "tensor(0.0157, grad_fn=<AddBackward0>)\n",
      "1528\n",
      "tensor(0.0673, grad_fn=<AddBackward0>)\n",
      "1530\n",
      "tensor(0.0643, grad_fn=<AddBackward0>)\n",
      "1532\n",
      "tensor(0.0718, grad_fn=<AddBackward0>)\n",
      "1534\n",
      "tensor(0.0754, grad_fn=<AddBackward0>)\n",
      "1536\n",
      "tensor(0.0709, grad_fn=<AddBackward0>)\n",
      "1538\n",
      "tensor(0.0762, grad_fn=<AddBackward0>)\n",
      "1540\n",
      "tensor(0.1004, grad_fn=<AddBackward0>)\n",
      "1542\n",
      "tensor(0.0708, grad_fn=<AddBackward0>)\n",
      "1544\n",
      "tensor(0.0504, grad_fn=<AddBackward0>)\n",
      "1546\n",
      "tensor(0.0740, grad_fn=<AddBackward0>)\n",
      "1548\n",
      "tensor(0.0581, grad_fn=<AddBackward0>)\n",
      "1550\n",
      "tensor(0.1140, grad_fn=<AddBackward0>)\n",
      "1552\n",
      "tensor(0.1059, grad_fn=<AddBackward0>)\n",
      "1554\n",
      "tensor(0.0557, grad_fn=<AddBackward0>)\n",
      "1556\n",
      "tensor(0.0837, grad_fn=<AddBackward0>)\n",
      "1558\n",
      "tensor(0.0692, grad_fn=<AddBackward0>)\n",
      "1560\n",
      "tensor(0.0684, grad_fn=<AddBackward0>)\n",
      "1562\n",
      "tensor(0.0389, grad_fn=<AddBackward0>)\n",
      "1564\n",
      "tensor(0.0703, grad_fn=<AddBackward0>)\n",
      "1566\n",
      "tensor(0.0783, grad_fn=<AddBackward0>)\n",
      "1568\n",
      "tensor(0.0739, grad_fn=<AddBackward0>)\n",
      "1570\n",
      "tensor(0.0826, grad_fn=<AddBackward0>)\n",
      "1572\n",
      "tensor(0.0873, grad_fn=<AddBackward0>)\n",
      "1574\n",
      "tensor(0.0537, grad_fn=<AddBackward0>)\n",
      "1576\n",
      "tensor(0.0727, grad_fn=<AddBackward0>)\n",
      "1578\n",
      "tensor(0.0551, grad_fn=<AddBackward0>)\n",
      "1580\n",
      "tensor(0.0654, grad_fn=<AddBackward0>)\n",
      "1582\n",
      "tensor(0.0375, grad_fn=<AddBackward0>)\n",
      "1584\n",
      "tensor(0.0760, grad_fn=<AddBackward0>)\n",
      "1586\n",
      "tensor(0.0871, grad_fn=<AddBackward0>)\n",
      "1588\n",
      "tensor(0.0948, grad_fn=<AddBackward0>)\n",
      "1590\n",
      "tensor(0.0959, grad_fn=<AddBackward0>)\n",
      "1592\n",
      "tensor(0.0802, grad_fn=<AddBackward0>)\n",
      "1594\n",
      "tensor(0.0896, grad_fn=<AddBackward0>)\n",
      "1596\n",
      "tensor(0.0711, grad_fn=<AddBackward0>)\n",
      "1598\n",
      "tensor(0.0686, grad_fn=<AddBackward0>)\n",
      "1600\n",
      "tensor(0.0676, grad_fn=<AddBackward0>)\n",
      "1602\n",
      "tensor(0.0691, grad_fn=<AddBackward0>)\n",
      "1604\n",
      "tensor(0.0576, grad_fn=<AddBackward0>)\n",
      "1606\n",
      "tensor(0.0938, grad_fn=<AddBackward0>)\n",
      "1608\n",
      "tensor(0.0662, grad_fn=<AddBackward0>)\n",
      "1610\n",
      "tensor(0.0738, grad_fn=<AddBackward0>)\n",
      "1612\n",
      "tensor(0.1152, grad_fn=<AddBackward0>)\n",
      "1614\n",
      "tensor(0.0766, grad_fn=<AddBackward0>)\n",
      "1616\n",
      "tensor(0.0714, grad_fn=<AddBackward0>)\n",
      "1618\n",
      "tensor(0.0594, grad_fn=<AddBackward0>)\n",
      "1620\n",
      "tensor(0.0955, grad_fn=<AddBackward0>)\n",
      "1622\n",
      "tensor(0.0911, grad_fn=<AddBackward0>)\n",
      "1624\n",
      "tensor(0.0647, grad_fn=<AddBackward0>)\n",
      "1626\n",
      "tensor(0.0762, grad_fn=<AddBackward0>)\n",
      "1628\n",
      "tensor(0.0791, grad_fn=<AddBackward0>)\n",
      "1630\n",
      "tensor(0.0825, grad_fn=<AddBackward0>)\n",
      "1632\n",
      "tensor(0.0649, grad_fn=<AddBackward0>)\n",
      "1634\n",
      "tensor(0.0803, grad_fn=<AddBackward0>)\n",
      "1636\n",
      "tensor(0.0783, grad_fn=<AddBackward0>)\n",
      "1638\n",
      "tensor(0.0618, grad_fn=<AddBackward0>)\n",
      "1640\n",
      "tensor(0.0761, grad_fn=<AddBackward0>)\n",
      "1642\n",
      "tensor(0.0709, grad_fn=<AddBackward0>)\n",
      "1644\n",
      "tensor(0.0690, grad_fn=<AddBackward0>)\n",
      "1646\n",
      "tensor(0.0683, grad_fn=<AddBackward0>)\n",
      "1648\n",
      "tensor(0.0621, grad_fn=<AddBackward0>)\n",
      "1650\n",
      "tensor(0.0934, grad_fn=<AddBackward0>)\n",
      "1652\n",
      "tensor(0.0608, grad_fn=<AddBackward0>)\n",
      "1654\n",
      "tensor(0.0582, grad_fn=<AddBackward0>)\n",
      "1656\n",
      "tensor(0.0774, grad_fn=<AddBackward0>)\n",
      "1658\n",
      "tensor(0.0390, grad_fn=<AddBackward0>)\n",
      "1660\n",
      "tensor(0.0697, grad_fn=<AddBackward0>)\n",
      "1662\n",
      "tensor(0.0634, grad_fn=<AddBackward0>)\n",
      "1664\n",
      "tensor(0.0654, grad_fn=<AddBackward0>)\n",
      "1666\n",
      "tensor(0.0649, grad_fn=<AddBackward0>)\n",
      "1668\n",
      "tensor(0.0984, grad_fn=<AddBackward0>)\n",
      "1670\n",
      "tensor(0.0780, grad_fn=<AddBackward0>)\n",
      "1672\n",
      "tensor(0.0667, grad_fn=<AddBackward0>)\n",
      "1674\n",
      "tensor(0.0678, grad_fn=<AddBackward0>)\n",
      "1676\n",
      "tensor(0.0547, grad_fn=<AddBackward0>)\n",
      "1678\n",
      "tensor(0.0762, grad_fn=<AddBackward0>)\n",
      "1680\n",
      "tensor(0.0660, grad_fn=<AddBackward0>)\n",
      "1682\n",
      "tensor(0.0693, grad_fn=<AddBackward0>)\n",
      "1684\n",
      "tensor(0.0854, grad_fn=<AddBackward0>)\n",
      "1686\n",
      "tensor(0.0617, grad_fn=<AddBackward0>)\n",
      "1688\n",
      "tensor(0.0719, grad_fn=<AddBackward0>)\n",
      "1690\n",
      "tensor(0.0634, grad_fn=<AddBackward0>)\n",
      "1692\n",
      "tensor(0.0675, grad_fn=<AddBackward0>)\n",
      "1694\n",
      "tensor(0.0727, grad_fn=<AddBackward0>)\n",
      "1696\n",
      "tensor(0.0812, grad_fn=<AddBackward0>)\n",
      "1698\n",
      "tensor(0.0867, grad_fn=<AddBackward0>)\n",
      "1700\n",
      "tensor(0.0778, grad_fn=<AddBackward0>)\n",
      "1702\n",
      "tensor(0.0696, grad_fn=<AddBackward0>)\n",
      "1704\n",
      "tensor(0.1151, grad_fn=<AddBackward0>)\n",
      "1706\n",
      "tensor(0.0821, grad_fn=<AddBackward0>)\n",
      "1708\n",
      "tensor(0.0681, grad_fn=<AddBackward0>)\n",
      "1710\n",
      "tensor(0.0734, grad_fn=<AddBackward0>)\n",
      "1712\n",
      "tensor(0.0770, grad_fn=<AddBackward0>)\n",
      "1714\n",
      "tensor(0.0635, grad_fn=<AddBackward0>)\n",
      "1716\n",
      "tensor(0.0569, grad_fn=<AddBackward0>)\n",
      "1718\n",
      "tensor(0.0719, grad_fn=<AddBackward0>)\n",
      "1720\n",
      "tensor(0.0672, grad_fn=<AddBackward0>)\n",
      "1722\n",
      "tensor(0.0770, grad_fn=<AddBackward0>)\n",
      "1724\n",
      "tensor(0.0832, grad_fn=<AddBackward0>)\n",
      "1726\n",
      "tensor(0.0751, grad_fn=<AddBackward0>)\n",
      "1728\n",
      "tensor(0.0799, grad_fn=<AddBackward0>)\n",
      "1730\n",
      "tensor(0.0958, grad_fn=<AddBackward0>)\n",
      "1732\n",
      "tensor(0.0589, grad_fn=<AddBackward0>)\n",
      "1734\n",
      "tensor(0.0550, grad_fn=<AddBackward0>)\n",
      "1736\n",
      "tensor(0.0608, grad_fn=<AddBackward0>)\n",
      "1738\n",
      "tensor(0.0823, grad_fn=<AddBackward0>)\n",
      "1740\n",
      "tensor(0.0650, grad_fn=<AddBackward0>)\n",
      "1742\n",
      "tensor(0.0890, grad_fn=<AddBackward0>)\n",
      "1744\n",
      "tensor(0.1163, grad_fn=<AddBackward0>)\n",
      "1746\n",
      "tensor(0.0832, grad_fn=<AddBackward0>)\n",
      "1748\n",
      "tensor(0.0690, grad_fn=<AddBackward0>)\n",
      "1750\n",
      "tensor(0.0688, grad_fn=<AddBackward0>)\n",
      "1752\n",
      "tensor(0.0522, grad_fn=<AddBackward0>)\n",
      "1754\n",
      "tensor(0.0740, grad_fn=<AddBackward0>)\n",
      "1756\n",
      "tensor(0.0685, grad_fn=<AddBackward0>)\n",
      "1758\n",
      "tensor(0.0712, grad_fn=<AddBackward0>)\n",
      "1760\n",
      "tensor(0.0527, grad_fn=<AddBackward0>)\n",
      "1762\n",
      "tensor(0.0713, grad_fn=<AddBackward0>)\n",
      "1764\n",
      "tensor(0.0722, grad_fn=<AddBackward0>)\n",
      "1766\n",
      "tensor(0.0678, grad_fn=<AddBackward0>)\n",
      "1768\n",
      "tensor(0.0721, grad_fn=<AddBackward0>)\n",
      "1770\n",
      "tensor(0.0819, grad_fn=<AddBackward0>)\n",
      "1772\n",
      "tensor(0.0573, grad_fn=<AddBackward0>)\n",
      "1774\n",
      "tensor(0.0793, grad_fn=<AddBackward0>)\n",
      "1776\n",
      "tensor(0.1020, grad_fn=<AddBackward0>)\n",
      "1778\n",
      "tensor(0.0729, grad_fn=<AddBackward0>)\n",
      "1780\n",
      "tensor(0.0714, grad_fn=<AddBackward0>)\n",
      "1782\n",
      "tensor(0.0721, grad_fn=<AddBackward0>)\n",
      "1784\n",
      "tensor(0.0649, grad_fn=<AddBackward0>)\n",
      "1786\n",
      "tensor(0.0552, grad_fn=<AddBackward0>)\n",
      "1788\n",
      "tensor(0.0766, grad_fn=<AddBackward0>)\n",
      "1790\n",
      "tensor(0.0559, grad_fn=<AddBackward0>)\n",
      "1792\n",
      "tensor(0.0740, grad_fn=<AddBackward0>)\n",
      "1794\n",
      "tensor(0.0936, grad_fn=<AddBackward0>)\n",
      "1796\n",
      "tensor(0.0457, grad_fn=<AddBackward0>)\n",
      "1798\n",
      "tensor(0.0726, grad_fn=<AddBackward0>)\n",
      "1800\n",
      "tensor(0.0800, grad_fn=<AddBackward0>)\n",
      "1802\n",
      "tensor(0.0790, grad_fn=<AddBackward0>)\n",
      "1804\n",
      "tensor(0.0988, grad_fn=<AddBackward0>)\n",
      "1806\n",
      "tensor(0.0842, grad_fn=<AddBackward0>)\n",
      "1808\n",
      "tensor(0.0757, grad_fn=<AddBackward0>)\n",
      "1810\n",
      "tensor(0.0598, grad_fn=<AddBackward0>)\n",
      "1812\n",
      "tensor(0.0607, grad_fn=<AddBackward0>)\n",
      "1814\n",
      "tensor(0.0546, grad_fn=<AddBackward0>)\n",
      "1816\n",
      "tensor(0.0701, grad_fn=<AddBackward0>)\n",
      "1818\n",
      "tensor(0.0641, grad_fn=<AddBackward0>)\n",
      "1820\n",
      "tensor(0.0827, grad_fn=<AddBackward0>)\n",
      "1822\n",
      "tensor(0.0594, grad_fn=<AddBackward0>)\n",
      "1824\n",
      "tensor(0.0690, grad_fn=<AddBackward0>)\n",
      "1826\n",
      "tensor(0.0748, grad_fn=<AddBackward0>)\n",
      "1828\n",
      "tensor(0.0817, grad_fn=<AddBackward0>)\n",
      "1830\n",
      "tensor(0.0569, grad_fn=<AddBackward0>)\n",
      "1832\n",
      "tensor(0.0694, grad_fn=<AddBackward0>)\n",
      "1834\n",
      "tensor(0.0602, grad_fn=<AddBackward0>)\n",
      "1836\n",
      "tensor(0.0606, grad_fn=<AddBackward0>)\n",
      "1838\n",
      "tensor(0.0743, grad_fn=<AddBackward0>)\n",
      "1840\n",
      "tensor(0.0720, grad_fn=<AddBackward0>)\n",
      "1842\n",
      "tensor(0.0536, grad_fn=<AddBackward0>)\n",
      "1844\n",
      "tensor(0.0709, grad_fn=<AddBackward0>)\n",
      "1846\n",
      "tensor(0.0614, grad_fn=<AddBackward0>)\n",
      "1848\n",
      "tensor(0.0708, grad_fn=<AddBackward0>)\n",
      "1850\n",
      "tensor(0.0525, grad_fn=<AddBackward0>)\n",
      "1852\n",
      "tensor(0.0617, grad_fn=<AddBackward0>)\n",
      "1854\n",
      "tensor(0.0749, grad_fn=<AddBackward0>)\n",
      "1856\n",
      "tensor(0.0629, grad_fn=<AddBackward0>)\n",
      "1858\n",
      "tensor(0.0742, grad_fn=<AddBackward0>)\n",
      "1860\n",
      "tensor(0.1063, grad_fn=<AddBackward0>)\n",
      "1862\n",
      "tensor(0.0565, grad_fn=<AddBackward0>)\n",
      "1864\n",
      "tensor(0.0753, grad_fn=<AddBackward0>)\n",
      "1866\n",
      "tensor(0.0705, grad_fn=<AddBackward0>)\n",
      "1868\n",
      "tensor(0.0746, grad_fn=<AddBackward0>)\n",
      "1870\n",
      "tensor(0.0690, grad_fn=<AddBackward0>)\n",
      "1872\n",
      "tensor(0.0661, grad_fn=<AddBackward0>)\n",
      "1874\n",
      "tensor(0.0933, grad_fn=<AddBackward0>)\n",
      "1876\n",
      "tensor(0.0700, grad_fn=<AddBackward0>)\n",
      "1878\n",
      "tensor(0.0837, grad_fn=<AddBackward0>)\n",
      "1880\n",
      "tensor(0.0646, grad_fn=<AddBackward0>)\n",
      "1882\n",
      "tensor(0.0601, grad_fn=<AddBackward0>)\n",
      "1884\n",
      "tensor(0.0821, grad_fn=<AddBackward0>)\n",
      "1886\n",
      "tensor(0.1018, grad_fn=<AddBackward0>)\n",
      "1888\n",
      "tensor(0.0312, grad_fn=<AddBackward0>)\n",
      "1890\n",
      "tensor(0.0816, grad_fn=<AddBackward0>)\n",
      "1892\n",
      "tensor(0.0787, grad_fn=<AddBackward0>)\n",
      "1894\n",
      "tensor(0.0761, grad_fn=<AddBackward0>)\n",
      "1896\n",
      "tensor(0.0824, grad_fn=<AddBackward0>)\n",
      "1898\n",
      "tensor(0.0833, grad_fn=<AddBackward0>)\n",
      "1900\n",
      "tensor(0.0620, grad_fn=<AddBackward0>)\n",
      "1902\n",
      "tensor(0.0518, grad_fn=<AddBackward0>)\n",
      "1904\n",
      "tensor(0.0345, grad_fn=<AddBackward0>)\n",
      "1906\n",
      "tensor(0.0825, grad_fn=<AddBackward0>)\n",
      "1908\n",
      "tensor(0.0760, grad_fn=<AddBackward0>)\n",
      "1910\n",
      "tensor(0.0609, grad_fn=<AddBackward0>)\n",
      "1912\n",
      "tensor(0.0586, grad_fn=<AddBackward0>)\n",
      "1914\n",
      "tensor(0.0656, grad_fn=<AddBackward0>)\n",
      "1916\n",
      "tensor(0.0865, grad_fn=<AddBackward0>)\n",
      "1918\n",
      "tensor(0.0624, grad_fn=<AddBackward0>)\n",
      "1920\n",
      "tensor(0.0808, grad_fn=<AddBackward0>)\n",
      "1922\n",
      "tensor(0.0430, grad_fn=<AddBackward0>)\n",
      "1924\n",
      "tensor(0.0610, grad_fn=<AddBackward0>)\n",
      "1926\n",
      "tensor(0.0753, grad_fn=<AddBackward0>)\n",
      "1928\n",
      "tensor(0.0619, grad_fn=<AddBackward0>)\n",
      "1930\n",
      "tensor(0.0712, grad_fn=<AddBackward0>)\n",
      "1932\n",
      "tensor(0.0783, grad_fn=<AddBackward0>)\n",
      "1934\n",
      "tensor(0.0648, grad_fn=<AddBackward0>)\n",
      "1936\n",
      "tensor(0.0511, grad_fn=<AddBackward0>)\n",
      "1938\n",
      "tensor(0.0929, grad_fn=<AddBackward0>)\n",
      "1940\n",
      "tensor(0.0590, grad_fn=<AddBackward0>)\n",
      "1942\n",
      "tensor(0.0701, grad_fn=<AddBackward0>)\n",
      "1944\n",
      "tensor(0.0714, grad_fn=<AddBackward0>)\n",
      "1946\n",
      "tensor(0.0661, grad_fn=<AddBackward0>)\n",
      "1948\n",
      "tensor(0.0804, grad_fn=<AddBackward0>)\n",
      "1950\n",
      "tensor(0.1012, grad_fn=<AddBackward0>)\n",
      "1952\n",
      "tensor(0.0596, grad_fn=<AddBackward0>)\n",
      "1954\n",
      "tensor(0.0792, grad_fn=<AddBackward0>)\n",
      "1956\n",
      "tensor(0.0962, grad_fn=<AddBackward0>)\n",
      "1958\n",
      "tensor(0.0708, grad_fn=<AddBackward0>)\n",
      "1960\n",
      "tensor(0.0791, grad_fn=<AddBackward0>)\n",
      "1962\n",
      "tensor(0.0732, grad_fn=<AddBackward0>)\n",
      "1964\n",
      "tensor(0.0831, grad_fn=<AddBackward0>)\n",
      "1966\n",
      "tensor(0.0610, grad_fn=<AddBackward0>)\n",
      "1968\n",
      "tensor(0.0630, grad_fn=<AddBackward0>)\n",
      "1970\n",
      "tensor(0.0891, grad_fn=<AddBackward0>)\n",
      "1972\n",
      "tensor(0.0540, grad_fn=<AddBackward0>)\n",
      "1974\n",
      "tensor(0.1283, grad_fn=<AddBackward0>)\n",
      "1976\n",
      "tensor(0.0816, grad_fn=<AddBackward0>)\n",
      "1978\n",
      "tensor(0.1154, grad_fn=<AddBackward0>)\n",
      "1980\n",
      "tensor(0.0572, grad_fn=<AddBackward0>)\n",
      "1982\n",
      "tensor(0.0842, grad_fn=<AddBackward0>)\n",
      "1984\n",
      "tensor(0.0819, grad_fn=<AddBackward0>)\n",
      "1986\n",
      "tensor(0.0733, grad_fn=<AddBackward0>)\n",
      "1988\n",
      "tensor(0.1286, grad_fn=<AddBackward0>)\n",
      "1990\n",
      "tensor(0.0711, grad_fn=<AddBackward0>)\n",
      "1992\n",
      "tensor(0.0790, grad_fn=<AddBackward0>)\n",
      "1994\n",
      "tensor(0.1008, grad_fn=<AddBackward0>)\n",
      "1996\n",
      "tensor(0.0868, grad_fn=<AddBackward0>)\n",
      "1998\n",
      "tensor(0.0647, grad_fn=<AddBackward0>)\n",
      "2000\n",
      "tensor(0.0840, grad_fn=<AddBackward0>)\n",
      "2002\n",
      "tensor(0.0786, grad_fn=<AddBackward0>)\n",
      "2004\n",
      "tensor(0.0550, grad_fn=<AddBackward0>)\n",
      "2006\n",
      "tensor(0.0859, grad_fn=<AddBackward0>)\n",
      "2008\n",
      "tensor(0.0906, grad_fn=<AddBackward0>)\n",
      "2010\n",
      "tensor(0.0708, grad_fn=<AddBackward0>)\n",
      "2012\n",
      "tensor(0.0789, grad_fn=<AddBackward0>)\n",
      "2014\n",
      "tensor(0.0660, grad_fn=<AddBackward0>)\n",
      "2016\n",
      "tensor(0.0246, grad_fn=<AddBackward0>)\n",
      "2018\n",
      "tensor(0.0940, grad_fn=<AddBackward0>)\n",
      "2020\n",
      "tensor(0.0688, grad_fn=<AddBackward0>)\n",
      "2022\n",
      "tensor(0.0635, grad_fn=<AddBackward0>)\n",
      "2024\n",
      "tensor(0.1060, grad_fn=<AddBackward0>)\n",
      "2026\n",
      "tensor(0.0807, grad_fn=<AddBackward0>)\n",
      "2028\n",
      "tensor(0.0725, grad_fn=<AddBackward0>)\n",
      "2030\n",
      "tensor(0.0801, grad_fn=<AddBackward0>)\n",
      "2032\n",
      "tensor(0.0864, grad_fn=<AddBackward0>)\n",
      "2034\n",
      "tensor(0.1025, grad_fn=<AddBackward0>)\n",
      "2036\n",
      "tensor(0.0843, grad_fn=<AddBackward0>)\n",
      "2038\n",
      "tensor(0.0910, grad_fn=<AddBackward0>)\n",
      "2040\n",
      "tensor(0.0455, grad_fn=<AddBackward0>)\n",
      "2042\n",
      "tensor(0.0617, grad_fn=<AddBackward0>)\n",
      "2044\n",
      "tensor(0.0831, grad_fn=<AddBackward0>)\n",
      "2046\n",
      "tensor(0.0782, grad_fn=<AddBackward0>)\n",
      "2048\n",
      "tensor(0.0718, grad_fn=<AddBackward0>)\n",
      "2050\n",
      "tensor(0.0725, grad_fn=<AddBackward0>)\n",
      "2052\n",
      "tensor(0.0735, grad_fn=<AddBackward0>)\n",
      "2054\n",
      "tensor(0.0984, grad_fn=<AddBackward0>)\n",
      "2056\n",
      "tensor(0.0728, grad_fn=<AddBackward0>)\n",
      "2058\n",
      "tensor(0.0833, grad_fn=<AddBackward0>)\n",
      "2060\n",
      "tensor(0.0775, grad_fn=<AddBackward0>)\n",
      "2062\n",
      "tensor(0.0602, grad_fn=<AddBackward0>)\n",
      "2064\n",
      "tensor(0.0783, grad_fn=<AddBackward0>)\n",
      "2066\n",
      "tensor(0.0710, grad_fn=<AddBackward0>)\n",
      "2068\n",
      "tensor(0.0739, grad_fn=<AddBackward0>)\n",
      "2070\n",
      "tensor(0.0641, grad_fn=<AddBackward0>)\n",
      "2072\n",
      "tensor(0.0415, grad_fn=<AddBackward0>)\n",
      "2074\n",
      "tensor(0.0853, grad_fn=<AddBackward0>)\n",
      "2076\n",
      "tensor(0.0692, grad_fn=<AddBackward0>)\n",
      "2078\n",
      "tensor(0.0840, grad_fn=<AddBackward0>)\n",
      "2080\n",
      "tensor(0.1304, grad_fn=<AddBackward0>)\n",
      "2082\n",
      "tensor(0.1162, grad_fn=<AddBackward0>)\n",
      "2084\n",
      "tensor(0.0714, grad_fn=<AddBackward0>)\n",
      "2086\n",
      "tensor(0.0569, grad_fn=<AddBackward0>)\n",
      "2088\n",
      "tensor(0.0703, grad_fn=<AddBackward0>)\n",
      "2090\n",
      "tensor(0.0643, grad_fn=<AddBackward0>)\n",
      "2092\n",
      "tensor(0.0814, grad_fn=<AddBackward0>)\n",
      "2094\n",
      "tensor(0.0625, grad_fn=<AddBackward0>)\n",
      "2096\n",
      "tensor(0.0683, grad_fn=<AddBackward0>)\n",
      "2098\n",
      "tensor(0.0969, grad_fn=<AddBackward0>)\n",
      "2100\n",
      "tensor(0.0843, grad_fn=<AddBackward0>)\n",
      "2102\n",
      "tensor(0.0841, grad_fn=<AddBackward0>)\n",
      "2104\n",
      "tensor(0.0892, grad_fn=<AddBackward0>)\n",
      "2106\n",
      "tensor(0.0690, grad_fn=<AddBackward0>)\n",
      "2108\n",
      "tensor(0.0559, grad_fn=<AddBackward0>)\n",
      "2110\n",
      "tensor(0.0705, grad_fn=<AddBackward0>)\n",
      "2112\n",
      "tensor(0.0672, grad_fn=<AddBackward0>)\n",
      "2114\n",
      "tensor(0.0802, grad_fn=<AddBackward0>)\n",
      "2116\n",
      "tensor(0.0430, grad_fn=<AddBackward0>)\n",
      "2118\n",
      "tensor(0.0859, grad_fn=<AddBackward0>)\n",
      "2120\n",
      "tensor(0.0832, grad_fn=<AddBackward0>)\n",
      "2122\n",
      "tensor(0.0669, grad_fn=<AddBackward0>)\n",
      "2124\n",
      "tensor(0.0593, grad_fn=<AddBackward0>)\n",
      "2126\n",
      "tensor(0.0648, grad_fn=<AddBackward0>)\n",
      "2128\n",
      "tensor(0.0637, grad_fn=<AddBackward0>)\n",
      "2130\n",
      "tensor(0.0659, grad_fn=<AddBackward0>)\n",
      "2132\n",
      "tensor(0.0671, grad_fn=<AddBackward0>)\n",
      "2134\n",
      "tensor(0.0665, grad_fn=<AddBackward0>)\n",
      "2136\n",
      "tensor(0.0720, grad_fn=<AddBackward0>)\n",
      "2138\n",
      "tensor(0.1133, grad_fn=<AddBackward0>)\n",
      "2140\n",
      "tensor(0.0613, grad_fn=<AddBackward0>)\n",
      "2142\n",
      "tensor(0.0694, grad_fn=<AddBackward0>)\n",
      "2144\n",
      "tensor(0.0657, grad_fn=<AddBackward0>)\n",
      "2146\n",
      "tensor(0.1129, grad_fn=<AddBackward0>)\n",
      "2148\n",
      "tensor(0.0712, grad_fn=<AddBackward0>)\n",
      "2150\n",
      "tensor(0.0787, grad_fn=<AddBackward0>)\n",
      "2152\n",
      "tensor(0.0906, grad_fn=<AddBackward0>)\n",
      "2154\n",
      "tensor(0.0820, grad_fn=<AddBackward0>)\n",
      "2156\n",
      "tensor(0.0674, grad_fn=<AddBackward0>)\n",
      "2158\n",
      "tensor(0.0858, grad_fn=<AddBackward0>)\n",
      "2160\n",
      "tensor(0.0706, grad_fn=<AddBackward0>)\n",
      "2162\n",
      "tensor(0.0749, grad_fn=<AddBackward0>)\n",
      "2164\n",
      "tensor(0.0827, grad_fn=<AddBackward0>)\n",
      "2166\n",
      "tensor(0.0840, grad_fn=<AddBackward0>)\n",
      "2168\n",
      "tensor(0.0638, grad_fn=<AddBackward0>)\n",
      "2170\n",
      "tensor(0.0661, grad_fn=<AddBackward0>)\n",
      "2172\n",
      "tensor(0.0834, grad_fn=<AddBackward0>)\n",
      "2174\n",
      "tensor(0.0556, grad_fn=<AddBackward0>)\n",
      "2176\n",
      "tensor(0.0857, grad_fn=<AddBackward0>)\n",
      "2178\n",
      "tensor(0.0834, grad_fn=<AddBackward0>)\n",
      "2180\n",
      "tensor(0.0696, grad_fn=<AddBackward0>)\n",
      "2182\n",
      "tensor(0.1518, grad_fn=<AddBackward0>)\n",
      "2184\n",
      "tensor(0.0788, grad_fn=<AddBackward0>)\n",
      "2186\n",
      "tensor(0.0734, grad_fn=<AddBackward0>)\n",
      "2188\n",
      "tensor(0.0479, grad_fn=<AddBackward0>)\n",
      "2190\n",
      "tensor(0.0943, grad_fn=<AddBackward0>)\n",
      "2192\n",
      "tensor(0.0695, grad_fn=<AddBackward0>)\n",
      "2194\n",
      "tensor(0.0942, grad_fn=<AddBackward0>)\n",
      "2196\n",
      "tensor(0.0638, grad_fn=<AddBackward0>)\n",
      "2198\n",
      "tensor(0.0768, grad_fn=<AddBackward0>)\n",
      "2200\n",
      "tensor(0.0797, grad_fn=<AddBackward0>)\n",
      "2202\n",
      "tensor(0.0820, grad_fn=<AddBackward0>)\n",
      "2204\n",
      "tensor(0.0952, grad_fn=<AddBackward0>)\n",
      "2206\n",
      "tensor(0.0767, grad_fn=<AddBackward0>)\n",
      "2208\n",
      "tensor(0.0786, grad_fn=<AddBackward0>)\n",
      "2210\n",
      "tensor(0.0773, grad_fn=<AddBackward0>)\n",
      "2212\n",
      "tensor(0.0956, grad_fn=<AddBackward0>)\n",
      "2214\n",
      "tensor(0.0532, grad_fn=<AddBackward0>)\n",
      "2216\n",
      "tensor(0.0078, grad_fn=<AddBackward0>)\n",
      "2218\n",
      "tensor(0.0715, grad_fn=<AddBackward0>)\n",
      "2220\n",
      "tensor(0.0794, grad_fn=<AddBackward0>)\n",
      "2222\n",
      "tensor(0.0576, grad_fn=<AddBackward0>)\n",
      "2224\n",
      "tensor(0.0707, grad_fn=<AddBackward0>)\n",
      "2226\n",
      "tensor(0.0609, grad_fn=<AddBackward0>)\n",
      "2228\n",
      "tensor(0.0802, grad_fn=<AddBackward0>)\n",
      "2230\n",
      "tensor(0.0675, grad_fn=<AddBackward0>)\n",
      "2232\n",
      "tensor(0.0786, grad_fn=<AddBackward0>)\n",
      "2234\n",
      "tensor(0.0431, grad_fn=<AddBackward0>)\n",
      "2236\n",
      "tensor(0.0708, grad_fn=<AddBackward0>)\n",
      "2238\n",
      "tensor(0.0756, grad_fn=<AddBackward0>)\n",
      "2240\n",
      "tensor(0.0722, grad_fn=<AddBackward0>)\n",
      "2242\n",
      "tensor(0.0917, grad_fn=<AddBackward0>)\n",
      "2244\n",
      "tensor(0.0806, grad_fn=<AddBackward0>)\n",
      "2246\n",
      "tensor(0.0725, grad_fn=<AddBackward0>)\n",
      "2248\n",
      "tensor(0.0927, grad_fn=<AddBackward0>)\n",
      "2250\n",
      "tensor(0.0705, grad_fn=<AddBackward0>)\n",
      "2252\n",
      "tensor(0.0606, grad_fn=<AddBackward0>)\n",
      "2254\n",
      "tensor(0.0561, grad_fn=<AddBackward0>)\n",
      "2256\n",
      "tensor(0.0120, grad_fn=<AddBackward0>)\n",
      "2258\n",
      "tensor(0.0754, grad_fn=<AddBackward0>)\n",
      "2260\n",
      "tensor(0.0763, grad_fn=<AddBackward0>)\n",
      "2262\n",
      "tensor(0.0761, grad_fn=<AddBackward0>)\n",
      "2264\n",
      "tensor(0.0638, grad_fn=<AddBackward0>)\n",
      "2266\n",
      "tensor(0.0648, grad_fn=<AddBackward0>)\n",
      "2268\n",
      "tensor(0.0735, grad_fn=<AddBackward0>)\n",
      "2270\n",
      "tensor(0.0588, grad_fn=<AddBackward0>)\n",
      "2272\n",
      "tensor(0.0858, grad_fn=<AddBackward0>)\n",
      "2274\n",
      "tensor(0.0781, grad_fn=<AddBackward0>)\n",
      "2276\n",
      "tensor(0.0634, grad_fn=<AddBackward0>)\n",
      "2278\n",
      "tensor(0.0459, grad_fn=<AddBackward0>)\n",
      "2280\n",
      "tensor(0.0751, grad_fn=<AddBackward0>)\n",
      "2282\n",
      "tensor(0.0261, grad_fn=<AddBackward0>)\n",
      "2284\n",
      "tensor(0.0810, grad_fn=<AddBackward0>)\n",
      "2286\n",
      "tensor(0.0877, grad_fn=<AddBackward0>)\n",
      "2288\n",
      "tensor(0.0913, grad_fn=<AddBackward0>)\n",
      "2290\n",
      "tensor(0.0912, grad_fn=<AddBackward0>)\n",
      "2292\n",
      "tensor(0.0848, grad_fn=<AddBackward0>)\n",
      "2294\n",
      "tensor(0.0633, grad_fn=<AddBackward0>)\n",
      "2296\n",
      "tensor(0.0861, grad_fn=<AddBackward0>)\n",
      "2298\n",
      "tensor(0.0485, grad_fn=<AddBackward0>)\n",
      "2300\n",
      "tensor(0.1052, grad_fn=<AddBackward0>)\n",
      "2302\n",
      "tensor(0.0795, grad_fn=<AddBackward0>)\n",
      "2304\n",
      "tensor(0.0639, grad_fn=<AddBackward0>)\n",
      "2306\n",
      "tensor(0.0899, grad_fn=<AddBackward0>)\n",
      "2308\n",
      "tensor(0.1058, grad_fn=<AddBackward0>)\n",
      "2310\n",
      "tensor(0.0445, grad_fn=<AddBackward0>)\n",
      "2312\n",
      "tensor(0.0873, grad_fn=<AddBackward0>)\n",
      "2314\n",
      "tensor(0.0607, grad_fn=<AddBackward0>)\n",
      "2316\n",
      "tensor(0.0682, grad_fn=<AddBackward0>)\n",
      "2318\n",
      "tensor(0.0773, grad_fn=<AddBackward0>)\n",
      "2320\n",
      "tensor(0.0682, grad_fn=<AddBackward0>)\n",
      "2322\n",
      "tensor(0.0689, grad_fn=<AddBackward0>)\n",
      "2324\n",
      "tensor(0.0723, grad_fn=<AddBackward0>)\n",
      "2326\n",
      "tensor(0.0619, grad_fn=<AddBackward0>)\n",
      "2328\n",
      "tensor(0.0736, grad_fn=<AddBackward0>)\n",
      "2330\n",
      "tensor(0.0566, grad_fn=<AddBackward0>)\n",
      "2332\n",
      "tensor(0.0775, grad_fn=<AddBackward0>)\n",
      "2334\n",
      "tensor(0.0733, grad_fn=<AddBackward0>)\n",
      "2336\n",
      "tensor(0.0836, grad_fn=<AddBackward0>)\n",
      "2338\n",
      "tensor(0.0518, grad_fn=<AddBackward0>)\n",
      "2340\n",
      "tensor(0.0602, grad_fn=<AddBackward0>)\n",
      "2342\n",
      "tensor(0.0907, grad_fn=<AddBackward0>)\n",
      "2344\n",
      "tensor(0.0537, grad_fn=<AddBackward0>)\n",
      "2346\n",
      "tensor(0.0833, grad_fn=<AddBackward0>)\n",
      "2348\n",
      "tensor(0.0614, grad_fn=<AddBackward0>)\n",
      "2350\n",
      "tensor(0.0824, grad_fn=<AddBackward0>)\n",
      "2352\n",
      "tensor(0.0741, grad_fn=<AddBackward0>)\n",
      "2354\n",
      "tensor(0.0734, grad_fn=<AddBackward0>)\n",
      "2356\n",
      "tensor(0.0507, grad_fn=<AddBackward0>)\n",
      "2358\n",
      "tensor(0.0741, grad_fn=<AddBackward0>)\n",
      "2360\n",
      "tensor(0.0644, grad_fn=<AddBackward0>)\n",
      "2362\n",
      "tensor(0.0910, grad_fn=<AddBackward0>)\n",
      "2364\n",
      "tensor(0.0591, grad_fn=<AddBackward0>)\n",
      "2366\n",
      "tensor(0.0673, grad_fn=<AddBackward0>)\n",
      "2368\n",
      "tensor(0.0820, grad_fn=<AddBackward0>)\n",
      "2370\n",
      "tensor(0.0899, grad_fn=<AddBackward0>)\n",
      "2372\n",
      "tensor(0.0560, grad_fn=<AddBackward0>)\n",
      "2374\n",
      "tensor(0.0654, grad_fn=<AddBackward0>)\n",
      "2376\n",
      "tensor(0.0752, grad_fn=<AddBackward0>)\n",
      "2378\n",
      "tensor(0.0813, grad_fn=<AddBackward0>)\n",
      "2380\n",
      "tensor(0.1025, grad_fn=<AddBackward0>)\n",
      "2382\n",
      "tensor(0.0619, grad_fn=<AddBackward0>)\n",
      "2384\n",
      "tensor(0.0612, grad_fn=<AddBackward0>)\n",
      "2386\n",
      "tensor(0.0814, grad_fn=<AddBackward0>)\n",
      "2388\n",
      "tensor(0.0780, grad_fn=<AddBackward0>)\n",
      "2390\n",
      "tensor(0.0806, grad_fn=<AddBackward0>)\n",
      "2392\n",
      "tensor(0.0721, grad_fn=<AddBackward0>)\n",
      "2394\n",
      "tensor(0.0795, grad_fn=<AddBackward0>)\n",
      "2396\n",
      "tensor(0.0726, grad_fn=<AddBackward0>)\n",
      "2398\n",
      "tensor(0.0918, grad_fn=<AddBackward0>)\n",
      "2400\n",
      "tensor(0.0691, grad_fn=<AddBackward0>)\n",
      "2402\n",
      "tensor(0.0871, grad_fn=<AddBackward0>)\n",
      "2404\n",
      "tensor(0.0629, grad_fn=<AddBackward0>)\n",
      "2406\n",
      "tensor(0.0837, grad_fn=<AddBackward0>)\n",
      "2408\n",
      "tensor(0.0681, grad_fn=<AddBackward0>)\n",
      "2410\n",
      "tensor(0.0662, grad_fn=<AddBackward0>)\n",
      "2412\n",
      "tensor(0.0717, grad_fn=<AddBackward0>)\n",
      "2414\n",
      "tensor(0.0718, grad_fn=<AddBackward0>)\n",
      "2416\n",
      "tensor(0.0639, grad_fn=<AddBackward0>)\n",
      "2418\n",
      "tensor(0.0724, grad_fn=<AddBackward0>)\n",
      "2420\n",
      "tensor(0.0621, grad_fn=<AddBackward0>)\n",
      "2422\n",
      "tensor(0.0729, grad_fn=<AddBackward0>)\n",
      "2424\n",
      "tensor(0.0722, grad_fn=<AddBackward0>)\n",
      "2426\n",
      "tensor(0.0688, grad_fn=<AddBackward0>)\n",
      "2428\n",
      "tensor(0.0517, grad_fn=<AddBackward0>)\n",
      "2430\n",
      "tensor(0.0614, grad_fn=<AddBackward0>)\n",
      "2432\n",
      "tensor(0.0772, grad_fn=<AddBackward0>)\n",
      "2434\n",
      "tensor(0.0762, grad_fn=<AddBackward0>)\n",
      "2436\n",
      "tensor(0.0698, grad_fn=<AddBackward0>)\n",
      "2438\n",
      "tensor(0.0740, grad_fn=<AddBackward0>)\n",
      "2440\n",
      "tensor(0.0750, grad_fn=<AddBackward0>)\n",
      "2442\n",
      "tensor(0.0694, grad_fn=<AddBackward0>)\n",
      "2444\n",
      "tensor(0.0751, grad_fn=<AddBackward0>)\n",
      "2446\n",
      "tensor(0.0520, grad_fn=<AddBackward0>)\n",
      "2448\n",
      "tensor(0.0722, grad_fn=<AddBackward0>)\n",
      "2450\n",
      "tensor(0.0262, grad_fn=<AddBackward0>)\n",
      "2452\n",
      "tensor(0.0738, grad_fn=<AddBackward0>)\n",
      "2454\n",
      "tensor(0.0642, grad_fn=<AddBackward0>)\n",
      "2456\n",
      "tensor(0.0559, grad_fn=<AddBackward0>)\n",
      "2458\n",
      "tensor(0.0753, grad_fn=<AddBackward0>)\n",
      "2460\n",
      "tensor(0.0771, grad_fn=<AddBackward0>)\n",
      "2462\n",
      "tensor(0.0696, grad_fn=<AddBackward0>)\n",
      "2464\n",
      "tensor(0.0474, grad_fn=<AddBackward0>)\n",
      "2466\n",
      "tensor(0.0763, grad_fn=<AddBackward0>)\n",
      "2468\n",
      "tensor(0.0883, grad_fn=<AddBackward0>)\n",
      "2470\n",
      "tensor(0.0593, grad_fn=<AddBackward0>)\n",
      "2472\n",
      "tensor(0.0609, grad_fn=<AddBackward0>)\n",
      "2474\n",
      "tensor(0.0747, grad_fn=<AddBackward0>)\n",
      "2476\n",
      "tensor(0.0591, grad_fn=<AddBackward0>)\n",
      "2478\n",
      "tensor(0.0682, grad_fn=<AddBackward0>)\n",
      "2480\n",
      "tensor(0.0604, grad_fn=<AddBackward0>)\n",
      "2482\n",
      "tensor(0.0767, grad_fn=<AddBackward0>)\n",
      "2484\n",
      "tensor(0.0581, grad_fn=<AddBackward0>)\n",
      "2486\n",
      "tensor(0.0638, grad_fn=<AddBackward0>)\n",
      "2488\n",
      "tensor(0.0633, grad_fn=<AddBackward0>)\n",
      "2490\n",
      "tensor(0.1126, grad_fn=<AddBackward0>)\n",
      "2492\n",
      "tensor(0.0707, grad_fn=<AddBackward0>)\n",
      "2494\n",
      "tensor(0.0780, grad_fn=<AddBackward0>)\n",
      "2496\n",
      "tensor(0.0621, grad_fn=<AddBackward0>)\n",
      "2498\n",
      "tensor(0.0719, grad_fn=<AddBackward0>)\n",
      "2500\n",
      "tensor(0.0759, grad_fn=<AddBackward0>)\n",
      "2502\n",
      "tensor(0.0694, grad_fn=<AddBackward0>)\n",
      "2504\n",
      "tensor(0.0771, grad_fn=<AddBackward0>)\n",
      "2506\n",
      "tensor(0.0491, grad_fn=<AddBackward0>)\n",
      "2508\n",
      "tensor(0.0599, grad_fn=<AddBackward0>)\n",
      "2510\n",
      "tensor(0.0678, grad_fn=<AddBackward0>)\n",
      "2512\n",
      "tensor(0.0745, grad_fn=<AddBackward0>)\n",
      "2514\n",
      "tensor(0.0654, grad_fn=<AddBackward0>)\n",
      "2516\n",
      "tensor(0.0707, grad_fn=<AddBackward0>)\n",
      "2518\n",
      "tensor(0.0597, grad_fn=<AddBackward0>)\n",
      "2520\n",
      "tensor(0.0555, grad_fn=<AddBackward0>)\n",
      "2522\n",
      "tensor(0.0671, grad_fn=<AddBackward0>)\n",
      "2524\n",
      "tensor(0.0751, grad_fn=<AddBackward0>)\n",
      "2526\n",
      "tensor(0.0862, grad_fn=<AddBackward0>)\n",
      "2528\n",
      "tensor(0.0767, grad_fn=<AddBackward0>)\n",
      "2530\n",
      "tensor(0.0740, grad_fn=<AddBackward0>)\n",
      "2532\n",
      "tensor(0.0924, grad_fn=<AddBackward0>)\n",
      "2534\n",
      "tensor(0.0836, grad_fn=<AddBackward0>)\n",
      "2536\n",
      "tensor(0.0671, grad_fn=<AddBackward0>)\n",
      "2538\n",
      "tensor(0.0923, grad_fn=<AddBackward0>)\n",
      "2540\n",
      "tensor(0.0610, grad_fn=<AddBackward0>)\n",
      "2542\n",
      "tensor(0.0759, grad_fn=<AddBackward0>)\n",
      "2544\n",
      "tensor(0.0712, grad_fn=<AddBackward0>)\n",
      "2546\n",
      "tensor(0.0904, grad_fn=<AddBackward0>)\n",
      "2548\n",
      "tensor(0.0610, grad_fn=<AddBackward0>)\n",
      "2550\n",
      "tensor(0.0692, grad_fn=<AddBackward0>)\n",
      "2552\n",
      "tensor(0.0693, grad_fn=<AddBackward0>)\n",
      "2554\n",
      "tensor(0.0878, grad_fn=<AddBackward0>)\n",
      "2556\n",
      "tensor(0.0486, grad_fn=<AddBackward0>)\n",
      "2558\n",
      "tensor(0.0724, grad_fn=<AddBackward0>)\n",
      "2560\n",
      "tensor(0.0648, grad_fn=<AddBackward0>)\n",
      "2562\n",
      "tensor(0.0987, grad_fn=<AddBackward0>)\n",
      "2564\n",
      "tensor(0.0700, grad_fn=<AddBackward0>)\n",
      "2566\n",
      "tensor(0.0764, grad_fn=<AddBackward0>)\n",
      "2568\n",
      "tensor(0.0970, grad_fn=<AddBackward0>)\n",
      "2570\n",
      "tensor(0.0710, grad_fn=<AddBackward0>)\n",
      "2572\n",
      "tensor(0.0749, grad_fn=<AddBackward0>)\n",
      "2574\n",
      "tensor(0.0504, grad_fn=<AddBackward0>)\n",
      "2576\n",
      "tensor(0.0519, grad_fn=<AddBackward0>)\n",
      "2578\n",
      "tensor(0.0738, grad_fn=<AddBackward0>)\n",
      "2580\n",
      "tensor(0.0741, grad_fn=<AddBackward0>)\n",
      "2582\n",
      "tensor(0.0771, grad_fn=<AddBackward0>)\n",
      "2584\n",
      "tensor(0.0809, grad_fn=<AddBackward0>)\n",
      "2586\n",
      "tensor(0.0751, grad_fn=<AddBackward0>)\n",
      "2588\n",
      "tensor(0.0711, grad_fn=<AddBackward0>)\n",
      "2590\n",
      "tensor(0.0795, grad_fn=<AddBackward0>)\n",
      "2592\n",
      "tensor(0.0673, grad_fn=<AddBackward0>)\n",
      "2594\n",
      "tensor(0.0590, grad_fn=<AddBackward0>)\n",
      "2596\n",
      "tensor(0.0411, grad_fn=<AddBackward0>)\n",
      "2598\n",
      "tensor(0.0769, grad_fn=<AddBackward0>)\n",
      "2600\n",
      "tensor(0.0638, grad_fn=<AddBackward0>)\n",
      "2602\n",
      "tensor(0.0618, grad_fn=<AddBackward0>)\n",
      "2604\n",
      "tensor(0.0790, grad_fn=<AddBackward0>)\n",
      "2606\n",
      "tensor(0.0660, grad_fn=<AddBackward0>)\n",
      "2608\n",
      "tensor(0.0772, grad_fn=<AddBackward0>)\n",
      "2610\n",
      "tensor(0.0761, grad_fn=<AddBackward0>)\n",
      "2612\n",
      "tensor(0.0899, grad_fn=<AddBackward0>)\n",
      "2614\n",
      "tensor(0.0789, grad_fn=<AddBackward0>)\n",
      "2616\n",
      "tensor(0.0695, grad_fn=<AddBackward0>)\n",
      "2618\n",
      "tensor(0.0883, grad_fn=<AddBackward0>)\n",
      "2620\n",
      "tensor(0.0713, grad_fn=<AddBackward0>)\n",
      "2622\n",
      "tensor(0.0732, grad_fn=<AddBackward0>)\n",
      "2624\n",
      "tensor(0.0714, grad_fn=<AddBackward0>)\n",
      "2626\n",
      "tensor(0.0894, grad_fn=<AddBackward0>)\n",
      "2628\n",
      "tensor(0.0761, grad_fn=<AddBackward0>)\n",
      "2630\n",
      "tensor(0.0835, grad_fn=<AddBackward0>)\n",
      "2632\n",
      "tensor(0.0763, grad_fn=<AddBackward0>)\n",
      "2634\n",
      "tensor(0.0769, grad_fn=<AddBackward0>)\n",
      "2636\n",
      "tensor(0.0723, grad_fn=<AddBackward0>)\n",
      "2638\n",
      "tensor(0.0711, grad_fn=<AddBackward0>)\n",
      "2640\n",
      "tensor(0.0626, grad_fn=<AddBackward0>)\n",
      "2642\n",
      "tensor(0.0914, grad_fn=<AddBackward0>)\n",
      "2644\n",
      "tensor(0.0649, grad_fn=<AddBackward0>)\n",
      "2646\n",
      "tensor(0.0796, grad_fn=<AddBackward0>)\n",
      "2648\n",
      "tensor(0.0632, grad_fn=<AddBackward0>)\n",
      "2650\n",
      "tensor(0.0679, grad_fn=<AddBackward0>)\n",
      "2652\n",
      "tensor(0.0869, grad_fn=<AddBackward0>)\n",
      "2654\n",
      "tensor(0.0818, grad_fn=<AddBackward0>)\n",
      "2656\n",
      "tensor(0.0684, grad_fn=<AddBackward0>)\n",
      "2658\n",
      "tensor(0.0619, grad_fn=<AddBackward0>)\n",
      "2660\n",
      "tensor(0.0808, grad_fn=<AddBackward0>)\n",
      "2662\n",
      "tensor(0.0786, grad_fn=<AddBackward0>)\n",
      "2664\n",
      "tensor(0.0586, grad_fn=<AddBackward0>)\n",
      "2666\n",
      "tensor(0.0723, grad_fn=<AddBackward0>)\n",
      "2668\n",
      "tensor(0.0585, grad_fn=<AddBackward0>)\n",
      "2670\n",
      "tensor(0.0722, grad_fn=<AddBackward0>)\n",
      "2672\n",
      "tensor(0.0922, grad_fn=<AddBackward0>)\n",
      "2674\n",
      "tensor(0.0655, grad_fn=<AddBackward0>)\n",
      "2676\n",
      "tensor(0.0570, grad_fn=<AddBackward0>)\n",
      "2678\n",
      "tensor(0.0745, grad_fn=<AddBackward0>)\n",
      "2680\n",
      "tensor(0.0824, grad_fn=<AddBackward0>)\n",
      "2682\n",
      "tensor(0.0837, grad_fn=<AddBackward0>)\n",
      "2684\n",
      "tensor(0.0840, grad_fn=<AddBackward0>)\n",
      "2686\n",
      "tensor(0.0634, grad_fn=<AddBackward0>)\n",
      "2688\n",
      "tensor(0.0894, grad_fn=<AddBackward0>)\n",
      "2690\n",
      "tensor(0.0609, grad_fn=<AddBackward0>)\n",
      "2692\n",
      "tensor(0.0633, grad_fn=<AddBackward0>)\n",
      "2694\n",
      "tensor(0.0802, grad_fn=<AddBackward0>)\n",
      "2696\n",
      "tensor(0.0251, grad_fn=<AddBackward0>)\n",
      "2698\n",
      "tensor(0.0615, grad_fn=<AddBackward0>)\n",
      "2700\n",
      "tensor(0.0930, grad_fn=<AddBackward0>)\n",
      "2702\n",
      "tensor(0.0784, grad_fn=<AddBackward0>)\n",
      "2704\n",
      "tensor(0.0560, grad_fn=<AddBackward0>)\n",
      "2706\n",
      "tensor(0.1062, grad_fn=<AddBackward0>)\n",
      "2708\n",
      "tensor(0.0744, grad_fn=<AddBackward0>)\n",
      "2710\n",
      "tensor(0.0616, grad_fn=<AddBackward0>)\n",
      "2712\n",
      "tensor(0.0557, grad_fn=<AddBackward0>)\n",
      "2714\n",
      "tensor(0.0865, grad_fn=<AddBackward0>)\n",
      "2716\n",
      "tensor(0.0633, grad_fn=<AddBackward0>)\n",
      "2718\n",
      "tensor(0.0770, grad_fn=<AddBackward0>)\n",
      "2720\n",
      "tensor(0.0762, grad_fn=<AddBackward0>)\n",
      "2722\n",
      "tensor(0.0644, grad_fn=<AddBackward0>)\n",
      "2724\n",
      "tensor(0.0652, grad_fn=<AddBackward0>)\n",
      "2726\n",
      "tensor(0.0611, grad_fn=<AddBackward0>)\n",
      "2728\n",
      "tensor(0.0655, grad_fn=<AddBackward0>)\n",
      "2730\n",
      "tensor(0.0823, grad_fn=<AddBackward0>)\n",
      "2732\n",
      "tensor(0.0787, grad_fn=<AddBackward0>)\n",
      "2734\n",
      "tensor(0.0647, grad_fn=<AddBackward0>)\n",
      "2736\n",
      "tensor(0.0609, grad_fn=<AddBackward0>)\n",
      "2738\n",
      "tensor(0.0788, grad_fn=<AddBackward0>)\n",
      "2740\n",
      "tensor(0.0843, grad_fn=<AddBackward0>)\n",
      "2742\n",
      "tensor(0.0634, grad_fn=<AddBackward0>)\n",
      "2744\n",
      "tensor(0.0655, grad_fn=<AddBackward0>)\n",
      "2746\n",
      "tensor(0.0783, grad_fn=<AddBackward0>)\n",
      "2748\n",
      "tensor(0.0647, grad_fn=<AddBackward0>)\n",
      "2750\n",
      "tensor(0.0856, grad_fn=<AddBackward0>)\n",
      "2752\n",
      "tensor(0.0669, grad_fn=<AddBackward0>)\n",
      "2754\n",
      "tensor(0.0664, grad_fn=<AddBackward0>)\n",
      "2756\n",
      "tensor(0.0854, grad_fn=<AddBackward0>)\n",
      "2758\n",
      "tensor(0.0736, grad_fn=<AddBackward0>)\n",
      "2760\n",
      "tensor(0.0505, grad_fn=<AddBackward0>)\n",
      "2762\n",
      "tensor(0.0891, grad_fn=<AddBackward0>)\n",
      "2764\n",
      "tensor(0.0415, grad_fn=<AddBackward0>)\n",
      "2766\n",
      "tensor(0.0731, grad_fn=<AddBackward0>)\n",
      "2768\n",
      "tensor(0.0597, grad_fn=<AddBackward0>)\n",
      "2770\n",
      "tensor(0.0826, grad_fn=<AddBackward0>)\n",
      "2772\n",
      "tensor(0.0599, grad_fn=<AddBackward0>)\n",
      "2774\n",
      "tensor(0.0593, grad_fn=<AddBackward0>)\n",
      "2776\n",
      "tensor(0.0951, grad_fn=<AddBackward0>)\n",
      "2778\n",
      "tensor(0.1496, grad_fn=<AddBackward0>)\n",
      "2780\n",
      "tensor(0.1326, grad_fn=<AddBackward0>)\n",
      "2782\n",
      "tensor(0.0684, grad_fn=<AddBackward0>)\n",
      "2784\n",
      "tensor(0.0794, grad_fn=<AddBackward0>)\n",
      "2786\n",
      "tensor(0.0913, grad_fn=<AddBackward0>)\n",
      "2788\n",
      "tensor(0.0833, grad_fn=<AddBackward0>)\n",
      "2790\n",
      "tensor(0.0611, grad_fn=<AddBackward0>)\n",
      "2792\n",
      "tensor(0.0828, grad_fn=<AddBackward0>)\n",
      "2794\n",
      "tensor(0.0556, grad_fn=<AddBackward0>)\n",
      "2796\n",
      "tensor(0.0615, grad_fn=<AddBackward0>)\n",
      "2798\n",
      "tensor(0.0756, grad_fn=<AddBackward0>)\n",
      "2800\n",
      "tensor(0.0552, grad_fn=<AddBackward0>)\n",
      "2802\n",
      "tensor(0.0712, grad_fn=<AddBackward0>)\n",
      "2804\n",
      "tensor(0.0706, grad_fn=<AddBackward0>)\n",
      "2806\n",
      "tensor(0.0599, grad_fn=<AddBackward0>)\n",
      "2808\n",
      "tensor(0.0661, grad_fn=<AddBackward0>)\n",
      "2810\n",
      "tensor(0.0817, grad_fn=<AddBackward0>)\n",
      "2812\n",
      "tensor(0.0532, grad_fn=<AddBackward0>)\n",
      "2814\n",
      "tensor(0.0691, grad_fn=<AddBackward0>)\n",
      "2816\n",
      "tensor(0.0657, grad_fn=<AddBackward0>)\n",
      "2818\n",
      "tensor(0.0849, grad_fn=<AddBackward0>)\n",
      "2820\n",
      "tensor(0.0626, grad_fn=<AddBackward0>)\n",
      "2822\n",
      "tensor(0.0741, grad_fn=<AddBackward0>)\n",
      "2824\n",
      "tensor(0.0447, grad_fn=<AddBackward0>)\n",
      "2826\n",
      "tensor(0.0609, grad_fn=<AddBackward0>)\n",
      "2828\n",
      "tensor(0.0803, grad_fn=<AddBackward0>)\n",
      "2830\n",
      "tensor(0.0822, grad_fn=<AddBackward0>)\n",
      "2832\n",
      "tensor(0.0949, grad_fn=<AddBackward0>)\n",
      "2834\n",
      "tensor(0.0896, grad_fn=<AddBackward0>)\n",
      "2836\n",
      "tensor(0.0781, grad_fn=<AddBackward0>)\n",
      "2838\n",
      "tensor(0.0814, grad_fn=<AddBackward0>)\n",
      "2840\n",
      "tensor(0.0679, grad_fn=<AddBackward0>)\n",
      "2842\n",
      "tensor(0.0639, grad_fn=<AddBackward0>)\n",
      "2844\n",
      "tensor(0.0658, grad_fn=<AddBackward0>)\n",
      "2846\n",
      "tensor(0.0582, grad_fn=<AddBackward0>)\n",
      "2848\n",
      "tensor(0.0839, grad_fn=<AddBackward0>)\n",
      "2850\n",
      "tensor(0.0825, grad_fn=<AddBackward0>)\n",
      "2852\n",
      "tensor(0.0635, grad_fn=<AddBackward0>)\n",
      "2854\n",
      "tensor(0.0689, grad_fn=<AddBackward0>)\n",
      "2856\n",
      "tensor(0.0612, grad_fn=<AddBackward0>)\n",
      "2858\n",
      "tensor(0.0785, grad_fn=<AddBackward0>)\n",
      "2860\n",
      "tensor(0.0761, grad_fn=<AddBackward0>)\n",
      "2862\n",
      "tensor(0.0786, grad_fn=<AddBackward0>)\n",
      "2864\n",
      "tensor(0.0729, grad_fn=<AddBackward0>)\n",
      "2866\n",
      "tensor(0.0953, grad_fn=<AddBackward0>)\n",
      "2868\n",
      "tensor(0.0768, grad_fn=<AddBackward0>)\n",
      "2870\n",
      "tensor(0.0483, grad_fn=<AddBackward0>)\n",
      "2872\n",
      "tensor(0.0872, grad_fn=<AddBackward0>)\n",
      "2874\n",
      "tensor(0.0520, grad_fn=<AddBackward0>)\n",
      "2876\n",
      "tensor(0.0561, grad_fn=<AddBackward0>)\n",
      "2878\n",
      "tensor(0.1011, grad_fn=<AddBackward0>)\n",
      "2880\n",
      "tensor(0.0843, grad_fn=<AddBackward0>)\n",
      "2882\n",
      "tensor(0.0642, grad_fn=<AddBackward0>)\n",
      "2884\n",
      "tensor(0.0527, grad_fn=<AddBackward0>)\n",
      "2886\n",
      "tensor(0.0631, grad_fn=<AddBackward0>)\n",
      "2888\n",
      "tensor(0.0863, grad_fn=<AddBackward0>)\n",
      "2890\n",
      "tensor(0.0657, grad_fn=<AddBackward0>)\n",
      "2892\n",
      "tensor(0.0767, grad_fn=<AddBackward0>)\n",
      "2894\n",
      "tensor(0.0634, grad_fn=<AddBackward0>)\n",
      "2896\n",
      "tensor(0.0741, grad_fn=<AddBackward0>)\n",
      "2898\n",
      "tensor(0.0843, grad_fn=<AddBackward0>)\n",
      "2900\n",
      "tensor(0.0793, grad_fn=<AddBackward0>)\n",
      "2902\n",
      "tensor(0.0907, grad_fn=<AddBackward0>)\n",
      "2904\n",
      "tensor(0.0816, grad_fn=<AddBackward0>)\n",
      "2906\n",
      "tensor(0.0746, grad_fn=<AddBackward0>)\n",
      "2908\n",
      "tensor(0.0809, grad_fn=<AddBackward0>)\n",
      "2910\n",
      "tensor(0.0600, grad_fn=<AddBackward0>)\n",
      "2912\n",
      "tensor(0.0569, grad_fn=<AddBackward0>)\n",
      "2914\n",
      "tensor(0.0842, grad_fn=<AddBackward0>)\n",
      "2916\n",
      "tensor(0.0944, grad_fn=<AddBackward0>)\n",
      "2918\n",
      "tensor(0.0615, grad_fn=<AddBackward0>)\n",
      "2920\n",
      "tensor(0.0758, grad_fn=<AddBackward0>)\n",
      "2922\n",
      "tensor(0.0758, grad_fn=<AddBackward0>)\n",
      "2924\n",
      "tensor(0.0737, grad_fn=<AddBackward0>)\n",
      "2926\n",
      "tensor(0.0867, grad_fn=<AddBackward0>)\n",
      "2928\n",
      "tensor(0.0549, grad_fn=<AddBackward0>)\n",
      "2930\n",
      "tensor(0.0779, grad_fn=<AddBackward0>)\n",
      "2932\n",
      "tensor(0.0728, grad_fn=<AddBackward0>)\n",
      "2934\n",
      "tensor(0.0859, grad_fn=<AddBackward0>)\n",
      "2936\n",
      "tensor(0.0854, grad_fn=<AddBackward0>)\n",
      "2938\n",
      "tensor(0.0848, grad_fn=<AddBackward0>)\n",
      "2940\n",
      "tensor(0.0854, grad_fn=<AddBackward0>)\n",
      "2942\n",
      "tensor(0.0766, grad_fn=<AddBackward0>)\n",
      "2944\n",
      "tensor(0.0700, grad_fn=<AddBackward0>)\n",
      "2946\n",
      "tensor(0.0776, grad_fn=<AddBackward0>)\n",
      "2948\n",
      "tensor(0.0841, grad_fn=<AddBackward0>)\n",
      "2950\n",
      "tensor(0.0725, grad_fn=<AddBackward0>)\n",
      "2952\n",
      "tensor(0.0728, grad_fn=<AddBackward0>)\n",
      "2954\n",
      "tensor(0.0863, grad_fn=<AddBackward0>)\n",
      "2956\n",
      "tensor(0.0525, grad_fn=<AddBackward0>)\n",
      "2958\n",
      "tensor(0.0983, grad_fn=<AddBackward0>)\n",
      "2960\n",
      "tensor(0.0703, grad_fn=<AddBackward0>)\n",
      "2962\n",
      "tensor(0.0705, grad_fn=<AddBackward0>)\n",
      "2964\n",
      "tensor(0.0716, grad_fn=<AddBackward0>)\n",
      "2966\n",
      "tensor(0.0889, grad_fn=<AddBackward0>)\n",
      "2968\n",
      "tensor(0.0459, grad_fn=<AddBackward0>)\n",
      "2970\n",
      "tensor(0.0671, grad_fn=<AddBackward0>)\n",
      "2972\n",
      "tensor(0.0675, grad_fn=<AddBackward0>)\n",
      "2974\n",
      "tensor(0.0809, grad_fn=<AddBackward0>)\n",
      "2976\n",
      "tensor(0.0680, grad_fn=<AddBackward0>)\n",
      "2978\n",
      "tensor(0.0515, grad_fn=<AddBackward0>)\n",
      "2980\n",
      "tensor(0.0567, grad_fn=<AddBackward0>)\n",
      "2982\n",
      "tensor(0.0799, grad_fn=<AddBackward0>)\n",
      "2984\n",
      "tensor(0.0827, grad_fn=<AddBackward0>)\n",
      "2986\n",
      "tensor(0.0701, grad_fn=<AddBackward0>)\n",
      "2988\n",
      "tensor(0.0655, grad_fn=<AddBackward0>)\n",
      "2990\n",
      "tensor(0.0628, grad_fn=<AddBackward0>)\n",
      "2992\n",
      "tensor(0.0688, grad_fn=<AddBackward0>)\n",
      "2994\n",
      "tensor(0.0710, grad_fn=<AddBackward0>)\n",
      "2996\n",
      "tensor(0.1830, grad_fn=<AddBackward0>)\n",
      "2998\n",
      "tensor(0.0626, grad_fn=<AddBackward0>)\n",
      "3000\n",
      "tensor(0.0451, grad_fn=<AddBackward0>)\n",
      "3002\n",
      "tensor(0.0630, grad_fn=<AddBackward0>)\n",
      "3004\n",
      "tensor(0.0817, grad_fn=<AddBackward0>)\n",
      "3006\n",
      "tensor(0.0741, grad_fn=<AddBackward0>)\n",
      "3008\n",
      "tensor(0.0744, grad_fn=<AddBackward0>)\n",
      "3010\n",
      "tensor(0.0748, grad_fn=<AddBackward0>)\n",
      "3012\n",
      "tensor(0.0672, grad_fn=<AddBackward0>)\n",
      "3014\n",
      "tensor(0.0561, grad_fn=<AddBackward0>)\n",
      "3016\n",
      "tensor(0.0819, grad_fn=<AddBackward0>)\n",
      "3018\n",
      "tensor(0.0474, grad_fn=<AddBackward0>)\n",
      "3020\n",
      "tensor(0.0573, grad_fn=<AddBackward0>)\n",
      "3022\n",
      "tensor(0.1053, grad_fn=<AddBackward0>)\n",
      "3024\n",
      "tensor(0.0609, grad_fn=<AddBackward0>)\n",
      "3026\n",
      "tensor(0.0814, grad_fn=<AddBackward0>)\n",
      "3028\n",
      "tensor(0.0626, grad_fn=<AddBackward0>)\n",
      "3030\n",
      "tensor(0.0686, grad_fn=<AddBackward0>)\n",
      "3032\n",
      "tensor(0.0816, grad_fn=<AddBackward0>)\n",
      "3034\n",
      "tensor(0.0606, grad_fn=<AddBackward0>)\n",
      "3036\n",
      "tensor(0.0598, grad_fn=<AddBackward0>)\n",
      "3038\n",
      "tensor(0.0752, grad_fn=<AddBackward0>)\n",
      "3040\n",
      "tensor(0.0794, grad_fn=<AddBackward0>)\n",
      "3042\n",
      "tensor(0.0601, grad_fn=<AddBackward0>)\n",
      "3044\n",
      "tensor(0.0689, grad_fn=<AddBackward0>)\n",
      "3046\n",
      "tensor(0.1048, grad_fn=<AddBackward0>)\n",
      "3048\n",
      "tensor(0.0763, grad_fn=<AddBackward0>)\n",
      "3050\n",
      "tensor(0.0663, grad_fn=<AddBackward0>)\n",
      "3052\n",
      "tensor(0.0600, grad_fn=<AddBackward0>)\n",
      "3054\n",
      "tensor(0.0756, grad_fn=<AddBackward0>)\n",
      "3056\n",
      "tensor(0.0786, grad_fn=<AddBackward0>)\n",
      "3058\n",
      "tensor(0.0691, grad_fn=<AddBackward0>)\n",
      "3060\n",
      "tensor(0.0639, grad_fn=<AddBackward0>)\n",
      "3062\n",
      "tensor(0.0594, grad_fn=<AddBackward0>)\n",
      "3064\n",
      "tensor(0.0588, grad_fn=<AddBackward0>)\n",
      "3066\n",
      "tensor(0.0776, grad_fn=<AddBackward0>)\n",
      "3068\n",
      "tensor(0.0760, grad_fn=<AddBackward0>)\n",
      "3070\n",
      "tensor(0.0715, grad_fn=<AddBackward0>)\n",
      "3072\n",
      "tensor(0.0807, grad_fn=<AddBackward0>)\n",
      "3074\n",
      "tensor(0.0838, grad_fn=<AddBackward0>)\n",
      "3076\n",
      "tensor(0.1274, grad_fn=<AddBackward0>)\n",
      "3078\n",
      "tensor(0.0869, grad_fn=<AddBackward0>)\n",
      "3080\n",
      "tensor(0.1073, grad_fn=<AddBackward0>)\n",
      "3082\n",
      "tensor(0.0811, grad_fn=<AddBackward0>)\n",
      "3084\n",
      "tensor(0.0744, grad_fn=<AddBackward0>)\n",
      "3086\n",
      "tensor(0.0589, grad_fn=<AddBackward0>)\n",
      "3088\n",
      "tensor(0.0760, grad_fn=<AddBackward0>)\n",
      "3090\n",
      "tensor(0.0659, grad_fn=<AddBackward0>)\n",
      "3092\n",
      "tensor(0.0974, grad_fn=<AddBackward0>)\n",
      "3094\n",
      "tensor(0.0796, grad_fn=<AddBackward0>)\n",
      "3096\n",
      "tensor(0.0606, grad_fn=<AddBackward0>)\n",
      "3098\n",
      "tensor(0.0719, grad_fn=<AddBackward0>)\n",
      "3100\n",
      "tensor(0.0701, grad_fn=<AddBackward0>)\n",
      "3102\n",
      "tensor(0.0774, grad_fn=<AddBackward0>)\n",
      "3104\n",
      "tensor(0.0747, grad_fn=<AddBackward0>)\n",
      "3106\n",
      "tensor(0.0605, grad_fn=<AddBackward0>)\n",
      "3108\n",
      "tensor(0.0770, grad_fn=<AddBackward0>)\n",
      "3110\n",
      "tensor(0.0597, grad_fn=<AddBackward0>)\n",
      "3112\n",
      "tensor(0.0707, grad_fn=<AddBackward0>)\n",
      "3114\n",
      "tensor(0.0820, grad_fn=<AddBackward0>)\n",
      "3116\n",
      "tensor(0.0673, grad_fn=<AddBackward0>)\n",
      "3118\n",
      "tensor(0.0697, grad_fn=<AddBackward0>)\n",
      "3120\n",
      "tensor(0.0811, grad_fn=<AddBackward0>)\n",
      "3122\n",
      "tensor(0.0819, grad_fn=<AddBackward0>)\n",
      "3124\n",
      "tensor(0.0785, grad_fn=<AddBackward0>)\n",
      "3126\n",
      "tensor(0.0737, grad_fn=<AddBackward0>)\n",
      "3128\n",
      "tensor(0.0643, grad_fn=<AddBackward0>)\n",
      "3130\n",
      "tensor(0.0613, grad_fn=<AddBackward0>)\n",
      "3132\n",
      "tensor(0.0789, grad_fn=<AddBackward0>)\n",
      "3134\n",
      "tensor(0.0496, grad_fn=<AddBackward0>)\n",
      "3136\n",
      "tensor(0.0634, grad_fn=<AddBackward0>)\n",
      "3138\n",
      "tensor(0.0016, grad_fn=<AddBackward0>)\n",
      "3140\n",
      "tensor(0.0778, grad_fn=<AddBackward0>)\n",
      "3142\n",
      "tensor(0.0671, grad_fn=<AddBackward0>)\n",
      "3144\n",
      "tensor(0.0665, grad_fn=<AddBackward0>)\n",
      "3146\n",
      "tensor(0.0695, grad_fn=<AddBackward0>)\n",
      "3148\n",
      "tensor(0.0739, grad_fn=<AddBackward0>)\n",
      "3150\n",
      "tensor(0.0616, grad_fn=<AddBackward0>)\n",
      "3152\n",
      "tensor(0.0698, grad_fn=<AddBackward0>)\n",
      "3154\n",
      "tensor(0.0580, grad_fn=<AddBackward0>)\n",
      "3156\n",
      "tensor(0.0803, grad_fn=<AddBackward0>)\n",
      "3158\n",
      "tensor(0.0792, grad_fn=<AddBackward0>)\n",
      "3160\n",
      "tensor(0.0702, grad_fn=<AddBackward0>)\n",
      "3162\n",
      "tensor(0.0567, grad_fn=<AddBackward0>)\n",
      "3164\n",
      "tensor(0.0737, grad_fn=<AddBackward0>)\n",
      "3166\n",
      "tensor(0.0614, grad_fn=<AddBackward0>)\n",
      "3168\n",
      "tensor(0.0627, grad_fn=<AddBackward0>)\n",
      "3170\n",
      "tensor(0.0589, grad_fn=<AddBackward0>)\n",
      "3172\n",
      "tensor(0.0659, grad_fn=<AddBackward0>)\n",
      "3174\n",
      "tensor(0.0703, grad_fn=<AddBackward0>)\n",
      "3176\n",
      "tensor(0.0818, grad_fn=<AddBackward0>)\n",
      "3178\n",
      "tensor(0.0847, grad_fn=<AddBackward0>)\n",
      "3180\n",
      "tensor(0.0853, grad_fn=<AddBackward0>)\n",
      "3182\n",
      "tensor(0.1838, grad_fn=<AddBackward0>)\n",
      "3184\n",
      "tensor(0.0582, grad_fn=<AddBackward0>)\n",
      "3186\n",
      "tensor(0.0719, grad_fn=<AddBackward0>)\n",
      "3188\n",
      "tensor(0.0562, grad_fn=<AddBackward0>)\n",
      "3190\n",
      "tensor(0.0524, grad_fn=<AddBackward0>)\n",
      "3192\n",
      "tensor(0.0577, grad_fn=<AddBackward0>)\n",
      "3194\n",
      "tensor(0.0887, grad_fn=<AddBackward0>)\n",
      "3196\n",
      "tensor(0.0735, grad_fn=<AddBackward0>)\n",
      "3198\n",
      "tensor(0.0705, grad_fn=<AddBackward0>)\n",
      "3200\n",
      "tensor(0.0671, grad_fn=<AddBackward0>)\n",
      "3202\n",
      "tensor(0.0838, grad_fn=<AddBackward0>)\n",
      "3204\n",
      "tensor(0.0991, grad_fn=<AddBackward0>)\n",
      "3206\n",
      "tensor(0.0839, grad_fn=<AddBackward0>)\n",
      "3208\n",
      "tensor(0.0718, grad_fn=<AddBackward0>)\n",
      "3210\n",
      "tensor(0.0711, grad_fn=<AddBackward0>)\n",
      "3212\n",
      "tensor(0.0747, grad_fn=<AddBackward0>)\n",
      "3214\n",
      "tensor(0.0991, grad_fn=<AddBackward0>)\n",
      "3216\n",
      "tensor(0.0589, grad_fn=<AddBackward0>)\n",
      "3218\n",
      "tensor(0.0854, grad_fn=<AddBackward0>)\n",
      "3220\n",
      "tensor(0.0879, grad_fn=<AddBackward0>)\n",
      "3222\n",
      "tensor(0.0769, grad_fn=<AddBackward0>)\n",
      "3224\n",
      "tensor(0.0590, grad_fn=<AddBackward0>)\n",
      "3226\n",
      "tensor(0.0726, grad_fn=<AddBackward0>)\n",
      "3228\n",
      "tensor(0.0733, grad_fn=<AddBackward0>)\n",
      "3230\n",
      "tensor(0.0622, grad_fn=<AddBackward0>)\n",
      "3232\n",
      "tensor(0.0855, grad_fn=<AddBackward0>)\n",
      "3234\n",
      "tensor(0.0839, grad_fn=<AddBackward0>)\n",
      "3236\n",
      "tensor(0.0675, grad_fn=<AddBackward0>)\n",
      "3238\n",
      "tensor(0.0806, grad_fn=<AddBackward0>)\n",
      "3240\n",
      "tensor(0.0840, grad_fn=<AddBackward0>)\n",
      "3242\n",
      "tensor(0.0718, grad_fn=<AddBackward0>)\n",
      "3244\n",
      "tensor(0.0553, grad_fn=<AddBackward0>)\n",
      "3246\n",
      "tensor(0.0772, grad_fn=<AddBackward0>)\n",
      "3248\n",
      "tensor(0.0680, grad_fn=<AddBackward0>)\n",
      "3250\n",
      "tensor(0.0717, grad_fn=<AddBackward0>)\n",
      "3252\n",
      "tensor(0.0636, grad_fn=<AddBackward0>)\n",
      "3254\n",
      "tensor(0.0622, grad_fn=<AddBackward0>)\n",
      "3256\n",
      "tensor(0.0924, grad_fn=<AddBackward0>)\n",
      "3258\n",
      "tensor(0.0779, grad_fn=<AddBackward0>)\n",
      "3260\n",
      "tensor(0.0566, grad_fn=<AddBackward0>)\n",
      "3262\n",
      "tensor(0.0652, grad_fn=<AddBackward0>)\n",
      "3264\n",
      "tensor(0.0704, grad_fn=<AddBackward0>)\n",
      "3266\n",
      "tensor(0.0750, grad_fn=<AddBackward0>)\n",
      "3268\n",
      "tensor(0.0713, grad_fn=<AddBackward0>)\n",
      "3270\n",
      "tensor(0.0666, grad_fn=<AddBackward0>)\n",
      "3272\n",
      "tensor(0.0781, grad_fn=<AddBackward0>)\n",
      "3274\n",
      "tensor(0.0700, grad_fn=<AddBackward0>)\n",
      "3276\n",
      "tensor(0.0966, grad_fn=<AddBackward0>)\n",
      "3278\n",
      "tensor(0.0535, grad_fn=<AddBackward0>)\n",
      "3280\n",
      "tensor(0.0815, grad_fn=<AddBackward0>)\n",
      "3282\n",
      "tensor(0.0780, grad_fn=<AddBackward0>)\n",
      "3284\n",
      "tensor(0.0756, grad_fn=<AddBackward0>)\n",
      "3286\n",
      "tensor(0.0653, grad_fn=<AddBackward0>)\n",
      "3288\n",
      "tensor(0.0788, grad_fn=<AddBackward0>)\n",
      "3290\n",
      "tensor(0.0648, grad_fn=<AddBackward0>)\n",
      "3292\n",
      "tensor(0.0685, grad_fn=<AddBackward0>)\n",
      "3294\n",
      "tensor(0.0637, grad_fn=<AddBackward0>)\n",
      "3296\n",
      "tensor(0.0594, grad_fn=<AddBackward0>)\n",
      "3298\n",
      "tensor(0.0676, grad_fn=<AddBackward0>)\n",
      "3300\n",
      "tensor(0.0518, grad_fn=<AddBackward0>)\n",
      "3302\n",
      "tensor(0.0624, grad_fn=<AddBackward0>)\n",
      "3304\n",
      "tensor(0.0889, grad_fn=<AddBackward0>)\n",
      "3306\n",
      "tensor(0.0461, grad_fn=<AddBackward0>)\n",
      "3308\n",
      "tensor(0.0626, grad_fn=<AddBackward0>)\n",
      "3310\n",
      "tensor(0.0673, grad_fn=<AddBackward0>)\n",
      "3312\n",
      "tensor(0.0717, grad_fn=<AddBackward0>)\n",
      "3314\n",
      "tensor(0.0705, grad_fn=<AddBackward0>)\n",
      "3316\n",
      "tensor(0.0607, grad_fn=<AddBackward0>)\n",
      "3318\n",
      "tensor(0.0848, grad_fn=<AddBackward0>)\n",
      "3320\n",
      "tensor(0.0950, grad_fn=<AddBackward0>)\n",
      "3322\n",
      "tensor(0.0561, grad_fn=<AddBackward0>)\n",
      "3324\n",
      "tensor(0.0544, grad_fn=<AddBackward0>)\n",
      "3326\n",
      "tensor(0.0679, grad_fn=<AddBackward0>)\n",
      "3328\n",
      "tensor(0.1046, grad_fn=<AddBackward0>)\n",
      "3330\n",
      "tensor(0.0790, grad_fn=<AddBackward0>)\n",
      "3332\n",
      "tensor(0.0600, grad_fn=<AddBackward0>)\n",
      "3334\n",
      "tensor(0.0947, grad_fn=<AddBackward0>)\n",
      "3336\n",
      "tensor(0.0866, grad_fn=<AddBackward0>)\n",
      "3338\n",
      "tensor(0.1121, grad_fn=<AddBackward0>)\n",
      "3340\n",
      "tensor(0.0613, grad_fn=<AddBackward0>)\n",
      "3342\n",
      "tensor(0.0873, grad_fn=<AddBackward0>)\n",
      "3344\n",
      "tensor(0.0750, grad_fn=<AddBackward0>)\n",
      "3346\n",
      "tensor(0.0671, grad_fn=<AddBackward0>)\n",
      "3348\n",
      "tensor(0.0806, grad_fn=<AddBackward0>)\n",
      "3350\n",
      "tensor(0.0625, grad_fn=<AddBackward0>)\n",
      "3352\n",
      "tensor(0.0649, grad_fn=<AddBackward0>)\n",
      "3354\n",
      "tensor(0.0721, grad_fn=<AddBackward0>)\n",
      "3356\n",
      "tensor(0.0698, grad_fn=<AddBackward0>)\n",
      "3358\n",
      "tensor(0.1111, grad_fn=<AddBackward0>)\n",
      "3360\n",
      "tensor(0.0662, grad_fn=<AddBackward0>)\n",
      "3362\n",
      "tensor(0.0825, grad_fn=<AddBackward0>)\n",
      "3364\n",
      "tensor(0.0749, grad_fn=<AddBackward0>)\n",
      "3366\n",
      "tensor(0.0619, grad_fn=<AddBackward0>)\n",
      "3368\n",
      "tensor(0.0676, grad_fn=<AddBackward0>)\n",
      "3370\n",
      "tensor(0.0842, grad_fn=<AddBackward0>)\n",
      "3372\n",
      "tensor(0.1951, grad_fn=<AddBackward0>)\n",
      "3374\n",
      "tensor(0.0454, grad_fn=<AddBackward0>)\n",
      "3376\n",
      "tensor(0.1116, grad_fn=<AddBackward0>)\n",
      "3378\n",
      "tensor(0.0596, grad_fn=<AddBackward0>)\n",
      "3380\n",
      "tensor(0.0622, grad_fn=<AddBackward0>)\n",
      "3382\n",
      "tensor(0.0667, grad_fn=<AddBackward0>)\n",
      "3384\n",
      "tensor(0.0869, grad_fn=<AddBackward0>)\n",
      "3386\n",
      "tensor(0.0640, grad_fn=<AddBackward0>)\n",
      "3388\n",
      "tensor(0.1043, grad_fn=<AddBackward0>)\n",
      "3390\n",
      "tensor(0.0654, grad_fn=<AddBackward0>)\n",
      "3392\n",
      "tensor(0.0683, grad_fn=<AddBackward0>)\n",
      "3394\n",
      "tensor(0.0614, grad_fn=<AddBackward0>)\n",
      "3396\n",
      "tensor(0.0655, grad_fn=<AddBackward0>)\n",
      "3398\n",
      "tensor(0.0898, grad_fn=<AddBackward0>)\n",
      "3400\n",
      "tensor(0.1035, grad_fn=<AddBackward0>)\n",
      "3402\n",
      "tensor(0.0951, grad_fn=<AddBackward0>)\n",
      "3404\n",
      "tensor(0.0696, grad_fn=<AddBackward0>)\n",
      "3406\n",
      "tensor(0.0409, grad_fn=<AddBackward0>)\n",
      "3408\n",
      "tensor(0.0812, grad_fn=<AddBackward0>)\n",
      "3410\n",
      "tensor(0.0934, grad_fn=<AddBackward0>)\n",
      "3412\n",
      "tensor(0.0949, grad_fn=<AddBackward0>)\n",
      "3414\n",
      "tensor(0.0846, grad_fn=<AddBackward0>)\n",
      "3416\n",
      "tensor(0.0781, grad_fn=<AddBackward0>)\n",
      "3418\n",
      "tensor(0.0692, grad_fn=<AddBackward0>)\n",
      "3420\n",
      "tensor(0.0846, grad_fn=<AddBackward0>)\n",
      "3422\n",
      "tensor(0.0803, grad_fn=<AddBackward0>)\n",
      "3424\n",
      "tensor(0.0947, grad_fn=<AddBackward0>)\n",
      "3426\n",
      "tensor(0.0712, grad_fn=<AddBackward0>)\n",
      "3428\n",
      "tensor(0.0782, grad_fn=<AddBackward0>)\n",
      "3430\n",
      "tensor(0.0674, grad_fn=<AddBackward0>)\n",
      "3432\n",
      "tensor(0.0652, grad_fn=<AddBackward0>)\n",
      "3434\n",
      "tensor(0.0638, grad_fn=<AddBackward0>)\n",
      "3436\n",
      "tensor(0.0640, grad_fn=<AddBackward0>)\n",
      "3438\n",
      "tensor(0.0746, grad_fn=<AddBackward0>)\n",
      "3440\n",
      "tensor(0.0572, grad_fn=<AddBackward0>)\n",
      "3442\n",
      "tensor(0.0757, grad_fn=<AddBackward0>)\n",
      "3444\n",
      "tensor(0.0522, grad_fn=<AddBackward0>)\n",
      "3446\n",
      "tensor(0.0761, grad_fn=<AddBackward0>)\n",
      "3448\n",
      "tensor(0.0803, grad_fn=<AddBackward0>)\n",
      "3450\n",
      "tensor(0.0645, grad_fn=<AddBackward0>)\n",
      "3452\n",
      "tensor(0.0617, grad_fn=<AddBackward0>)\n",
      "3454\n",
      "tensor(0.0566, grad_fn=<AddBackward0>)\n",
      "3456\n",
      "tensor(0.0966, grad_fn=<AddBackward0>)\n",
      "3458\n",
      "tensor(0.0833, grad_fn=<AddBackward0>)\n",
      "3460\n",
      "tensor(0.0989, grad_fn=<AddBackward0>)\n",
      "3462\n",
      "tensor(0.0736, grad_fn=<AddBackward0>)\n",
      "3464\n",
      "tensor(0.0538, grad_fn=<AddBackward0>)\n",
      "3466\n",
      "tensor(0.0587, grad_fn=<AddBackward0>)\n",
      "3468\n",
      "tensor(0.1002, grad_fn=<AddBackward0>)\n",
      "3470\n",
      "tensor(0.1017, grad_fn=<AddBackward0>)\n",
      "3472\n",
      "tensor(0.0858, grad_fn=<AddBackward0>)\n",
      "3474\n",
      "tensor(0.0629, grad_fn=<AddBackward0>)\n",
      "3476\n",
      "tensor(0.0690, grad_fn=<AddBackward0>)\n",
      "3478\n",
      "tensor(0.0550, grad_fn=<AddBackward0>)\n",
      "3480\n",
      "tensor(0.0894, grad_fn=<AddBackward0>)\n",
      "3482\n",
      "tensor(0.0798, grad_fn=<AddBackward0>)\n",
      "3484\n",
      "tensor(0.0713, grad_fn=<AddBackward0>)\n",
      "3486\n",
      "tensor(0.0699, grad_fn=<AddBackward0>)\n",
      "3488\n",
      "tensor(0.0670, grad_fn=<AddBackward0>)\n",
      "3490\n",
      "tensor(0.0646, grad_fn=<AddBackward0>)\n",
      "3492\n",
      "tensor(0.0704, grad_fn=<AddBackward0>)\n",
      "3494\n",
      "tensor(0.0449, grad_fn=<AddBackward0>)\n",
      "3496\n",
      "tensor(0.0966, grad_fn=<AddBackward0>)\n",
      "3498\n",
      "tensor(0.0858, grad_fn=<AddBackward0>)\n",
      "3500\n",
      "tensor(0.0639, grad_fn=<AddBackward0>)\n",
      "3502\n",
      "tensor(0.0443, grad_fn=<AddBackward0>)\n",
      "3504\n",
      "tensor(0.0629, grad_fn=<AddBackward0>)\n",
      "3506\n",
      "tensor(0.0909, grad_fn=<AddBackward0>)\n",
      "3508\n",
      "tensor(0.0546, grad_fn=<AddBackward0>)\n",
      "3510\n",
      "tensor(0.0830, grad_fn=<AddBackward0>)\n",
      "3512\n",
      "tensor(0.0636, grad_fn=<AddBackward0>)\n",
      "3514\n",
      "tensor(0.0619, grad_fn=<AddBackward0>)\n",
      "3516\n",
      "tensor(0.0710, grad_fn=<AddBackward0>)\n",
      "3518\n",
      "tensor(0.0692, grad_fn=<AddBackward0>)\n",
      "3520\n",
      "tensor(0.0674, grad_fn=<AddBackward0>)\n",
      "3522\n",
      "tensor(0.0638, grad_fn=<AddBackward0>)\n",
      "3524\n",
      "tensor(0.1132, grad_fn=<AddBackward0>)\n",
      "3526\n",
      "tensor(0.0694, grad_fn=<AddBackward0>)\n",
      "3528\n",
      "tensor(0.0946, grad_fn=<AddBackward0>)\n",
      "3530\n",
      "tensor(0.0830, grad_fn=<AddBackward0>)\n",
      "3532\n",
      "tensor(0.0620, grad_fn=<AddBackward0>)\n",
      "3534\n",
      "tensor(0.1119, grad_fn=<AddBackward0>)\n",
      "3536\n",
      "tensor(0.0742, grad_fn=<AddBackward0>)\n",
      "3538\n",
      "tensor(0.0734, grad_fn=<AddBackward0>)\n",
      "3540\n",
      "tensor(0.0848, grad_fn=<AddBackward0>)\n",
      "3542\n",
      "tensor(0.0698, grad_fn=<AddBackward0>)\n",
      "3544\n",
      "tensor(0.0880, grad_fn=<AddBackward0>)\n",
      "3546\n",
      "tensor(0.0749, grad_fn=<AddBackward0>)\n",
      "3548\n",
      "tensor(0.0685, grad_fn=<AddBackward0>)\n",
      "3550\n",
      "tensor(0.0578, grad_fn=<AddBackward0>)\n",
      "3552\n",
      "tensor(0.0471, grad_fn=<AddBackward0>)\n",
      "3554\n",
      "tensor(0.0630, grad_fn=<AddBackward0>)\n",
      "3556\n",
      "tensor(0.0811, grad_fn=<AddBackward0>)\n",
      "3558\n",
      "tensor(0.0828, grad_fn=<AddBackward0>)\n",
      "3560\n",
      "tensor(0.0831, grad_fn=<AddBackward0>)\n",
      "3562\n",
      "tensor(0.0860, grad_fn=<AddBackward0>)\n",
      "3564\n",
      "tensor(0.0730, grad_fn=<AddBackward0>)\n",
      "3566\n",
      "tensor(0.0541, grad_fn=<AddBackward0>)\n",
      "3568\n",
      "tensor(0.0632, grad_fn=<AddBackward0>)\n",
      "3570\n",
      "tensor(0.0774, grad_fn=<AddBackward0>)\n",
      "3572\n",
      "tensor(0.0607, grad_fn=<AddBackward0>)\n",
      "3574\n",
      "tensor(0.1034, grad_fn=<AddBackward0>)\n",
      "3576\n",
      "tensor(0.0812, grad_fn=<AddBackward0>)\n",
      "3578\n",
      "tensor(0.0673, grad_fn=<AddBackward0>)\n",
      "3580\n",
      "tensor(0.0764, grad_fn=<AddBackward0>)\n",
      "3582\n",
      "tensor(0.0816, grad_fn=<AddBackward0>)\n",
      "3584\n",
      "tensor(0.0719, grad_fn=<AddBackward0>)\n",
      "3586\n",
      "tensor(0.0775, grad_fn=<AddBackward0>)\n",
      "3588\n",
      "tensor(0.0649, grad_fn=<AddBackward0>)\n",
      "3590\n",
      "tensor(0.0786, grad_fn=<AddBackward0>)\n",
      "3592\n",
      "tensor(0.0616, grad_fn=<AddBackward0>)\n",
      "3594\n",
      "tensor(0.0692, grad_fn=<AddBackward0>)\n",
      "3596\n",
      "tensor(0.0716, grad_fn=<AddBackward0>)\n",
      "3598\n",
      "tensor(0.0611, grad_fn=<AddBackward0>)\n",
      "3600\n",
      "tensor(0.0417, grad_fn=<AddBackward0>)\n",
      "3602\n",
      "tensor(0.0789, grad_fn=<AddBackward0>)\n",
      "3604\n",
      "tensor(0.0628, grad_fn=<AddBackward0>)\n",
      "3606\n",
      "tensor(0.0607, grad_fn=<AddBackward0>)\n",
      "3608\n",
      "tensor(0.0522, grad_fn=<AddBackward0>)\n",
      "3610\n",
      "tensor(0.0789, grad_fn=<AddBackward0>)\n",
      "3612\n",
      "tensor(0.0795, grad_fn=<AddBackward0>)\n",
      "3614\n",
      "tensor(0.0610, grad_fn=<AddBackward0>)\n",
      "3616\n",
      "tensor(0.0854, grad_fn=<AddBackward0>)\n",
      "3618\n",
      "tensor(0.0760, grad_fn=<AddBackward0>)\n",
      "3620\n",
      "tensor(0.0889, grad_fn=<AddBackward0>)\n",
      "3622\n",
      "tensor(0.0689, grad_fn=<AddBackward0>)\n",
      "3624\n",
      "tensor(0.1043, grad_fn=<AddBackward0>)\n",
      "3626\n",
      "tensor(0.0709, grad_fn=<AddBackward0>)\n",
      "3628\n",
      "tensor(0.0736, grad_fn=<AddBackward0>)\n",
      "3630\n",
      "tensor(0.0550, grad_fn=<AddBackward0>)\n",
      "3632\n",
      "tensor(0.0902, grad_fn=<AddBackward0>)\n",
      "3634\n",
      "tensor(0.0653, grad_fn=<AddBackward0>)\n",
      "3636\n",
      "tensor(0.0979, grad_fn=<AddBackward0>)\n",
      "3638\n",
      "tensor(0.0761, grad_fn=<AddBackward0>)\n",
      "3640\n",
      "tensor(0.0762, grad_fn=<AddBackward0>)\n",
      "3642\n",
      "tensor(0.0631, grad_fn=<AddBackward0>)\n",
      "3644\n",
      "tensor(0.0745, grad_fn=<AddBackward0>)\n",
      "3646\n",
      "tensor(0.0718, grad_fn=<AddBackward0>)\n",
      "3648\n",
      "tensor(0.0706, grad_fn=<AddBackward0>)\n",
      "3650\n",
      "tensor(0.0667, grad_fn=<AddBackward0>)\n",
      "3652\n",
      "tensor(0.0639, grad_fn=<AddBackward0>)\n",
      "3654\n",
      "tensor(0.0897, grad_fn=<AddBackward0>)\n",
      "3656\n",
      "tensor(0.0900, grad_fn=<AddBackward0>)\n",
      "3658\n",
      "tensor(0.0642, grad_fn=<AddBackward0>)\n",
      "3660\n",
      "tensor(0.0671, grad_fn=<AddBackward0>)\n",
      "3662\n",
      "tensor(0.0714, grad_fn=<AddBackward0>)\n",
      "3664\n",
      "tensor(0.0647, grad_fn=<AddBackward0>)\n",
      "3666\n",
      "tensor(0.0875, grad_fn=<AddBackward0>)\n",
      "3668\n",
      "tensor(0.1373, grad_fn=<AddBackward0>)\n",
      "3670\n",
      "tensor(0.0565, grad_fn=<AddBackward0>)\n",
      "3672\n",
      "tensor(0.0562, grad_fn=<AddBackward0>)\n",
      "3674\n",
      "tensor(0.0849, grad_fn=<AddBackward0>)\n",
      "3676\n",
      "tensor(0.0811, grad_fn=<AddBackward0>)\n",
      "3678\n",
      "tensor(0.0676, grad_fn=<AddBackward0>)\n",
      "3680\n",
      "tensor(0.0564, grad_fn=<AddBackward0>)\n",
      "3682\n",
      "tensor(0.0841, grad_fn=<AddBackward0>)\n",
      "3684\n",
      "tensor(0.0664, grad_fn=<AddBackward0>)\n",
      "3686\n",
      "tensor(0.0879, grad_fn=<AddBackward0>)\n",
      "3688\n",
      "tensor(0.0603, grad_fn=<AddBackward0>)\n",
      "3690\n",
      "tensor(0.0823, grad_fn=<AddBackward0>)\n",
      "3692\n",
      "tensor(0.0687, grad_fn=<AddBackward0>)\n",
      "3694\n",
      "tensor(0.0771, grad_fn=<AddBackward0>)\n",
      "3696\n",
      "tensor(0.0476, grad_fn=<AddBackward0>)\n",
      "3698\n",
      "tensor(0.0777, grad_fn=<AddBackward0>)\n",
      "3700\n",
      "tensor(0.0665, grad_fn=<AddBackward0>)\n",
      "3702\n",
      "tensor(0.0662, grad_fn=<AddBackward0>)\n",
      "3704\n",
      "tensor(0.0803, grad_fn=<AddBackward0>)\n",
      "3706\n",
      "tensor(0.0189, grad_fn=<AddBackward0>)\n",
      "3708\n",
      "tensor(0.0664, grad_fn=<AddBackward0>)\n",
      "3710\n",
      "tensor(0.0891, grad_fn=<AddBackward0>)\n",
      "3712\n",
      "tensor(0.0991, grad_fn=<AddBackward0>)\n",
      "3714\n",
      "tensor(0.0581, grad_fn=<AddBackward0>)\n",
      "3716\n",
      "tensor(0.0736, grad_fn=<AddBackward0>)\n",
      "3718\n",
      "tensor(0.0756, grad_fn=<AddBackward0>)\n",
      "3720\n",
      "tensor(0.0887, grad_fn=<AddBackward0>)\n",
      "3722\n",
      "tensor(0.0134, grad_fn=<AddBackward0>)\n",
      "3724\n",
      "tensor(0.0782, grad_fn=<AddBackward0>)\n",
      "3726\n",
      "tensor(0.0582, grad_fn=<AddBackward0>)\n",
      "3728\n",
      "tensor(0.0689, grad_fn=<AddBackward0>)\n",
      "3730\n",
      "tensor(0.1026, grad_fn=<AddBackward0>)\n",
      "3732\n",
      "tensor(0.1239, grad_fn=<AddBackward0>)\n",
      "3734\n",
      "tensor(0.0572, grad_fn=<AddBackward0>)\n",
      "3736\n",
      "tensor(0.0711, grad_fn=<AddBackward0>)\n",
      "3738\n",
      "tensor(0.0320, grad_fn=<AddBackward0>)\n",
      "3740\n",
      "tensor(0.0809, grad_fn=<AddBackward0>)\n",
      "3742\n",
      "tensor(0.0717, grad_fn=<AddBackward0>)\n",
      "3744\n",
      "tensor(0.0710, grad_fn=<AddBackward0>)\n",
      "3746\n",
      "tensor(0.0637, grad_fn=<AddBackward0>)\n",
      "3748\n",
      "tensor(0.0788, grad_fn=<AddBackward0>)\n",
      "3750\n",
      "tensor(0.0707, grad_fn=<AddBackward0>)\n",
      "3752\n",
      "tensor(0.0737, grad_fn=<AddBackward0>)\n",
      "3754\n",
      "tensor(0.0834, grad_fn=<AddBackward0>)\n",
      "3756\n",
      "tensor(0.0730, grad_fn=<AddBackward0>)\n",
      "3758\n",
      "tensor(0.0860, grad_fn=<AddBackward0>)\n",
      "3760\n",
      "tensor(0.0665, grad_fn=<AddBackward0>)\n",
      "3762\n",
      "tensor(0.0689, grad_fn=<AddBackward0>)\n",
      "3764\n",
      "tensor(0.0576, grad_fn=<AddBackward0>)\n",
      "3766\n",
      "tensor(0.0669, grad_fn=<AddBackward0>)\n",
      "3768\n",
      "tensor(0.0490, grad_fn=<AddBackward0>)\n",
      "3770\n",
      "tensor(0.0816, grad_fn=<AddBackward0>)\n",
      "3772\n",
      "tensor(0.0688, grad_fn=<AddBackward0>)\n",
      "3774\n",
      "tensor(0.0664, grad_fn=<AddBackward0>)\n",
      "3776\n",
      "tensor(0.0756, grad_fn=<AddBackward0>)\n",
      "3778\n",
      "tensor(0.0630, grad_fn=<AddBackward0>)\n",
      "3780\n",
      "tensor(0.0753, grad_fn=<AddBackward0>)\n",
      "3782\n",
      "tensor(0.0678, grad_fn=<AddBackward0>)\n",
      "3784\n",
      "tensor(0.0634, grad_fn=<AddBackward0>)\n",
      "3786\n",
      "tensor(0.0570, grad_fn=<AddBackward0>)\n",
      "3788\n",
      "tensor(0.0735, grad_fn=<AddBackward0>)\n",
      "3790\n",
      "tensor(0.0375, grad_fn=<AddBackward0>)\n",
      "3792\n",
      "tensor(0.0642, grad_fn=<AddBackward0>)\n",
      "3794\n",
      "tensor(0.0797, grad_fn=<AddBackward0>)\n",
      "3796\n",
      "tensor(0.0666, grad_fn=<AddBackward0>)\n",
      "3798\n",
      "tensor(0.0738, grad_fn=<AddBackward0>)\n",
      "3800\n",
      "tensor(0.0808, grad_fn=<AddBackward0>)\n",
      "3802\n",
      "tensor(0.0618, grad_fn=<AddBackward0>)\n",
      "3804\n",
      "tensor(0.0845, grad_fn=<AddBackward0>)\n",
      "3806\n",
      "tensor(0.0681, grad_fn=<AddBackward0>)\n",
      "3808\n",
      "tensor(0.0568, grad_fn=<AddBackward0>)\n",
      "3810\n",
      "tensor(0.0959, grad_fn=<AddBackward0>)\n",
      "3812\n",
      "tensor(0.0720, grad_fn=<AddBackward0>)\n",
      "3814\n",
      "tensor(0.0601, grad_fn=<AddBackward0>)\n",
      "3816\n",
      "tensor(0.0594, grad_fn=<AddBackward0>)\n",
      "3818\n",
      "tensor(0.0674, grad_fn=<AddBackward0>)\n",
      "3820\n",
      "tensor(0.0634, grad_fn=<AddBackward0>)\n",
      "3822\n",
      "tensor(0.0893, grad_fn=<AddBackward0>)\n",
      "3824\n",
      "tensor(0.0656, grad_fn=<AddBackward0>)\n",
      "3826\n",
      "tensor(0.0937, grad_fn=<AddBackward0>)\n",
      "3828\n",
      "tensor(0.0698, grad_fn=<AddBackward0>)\n",
      "3830\n",
      "tensor(0.0774, grad_fn=<AddBackward0>)\n",
      "3832\n",
      "tensor(0.0810, grad_fn=<AddBackward0>)\n",
      "3834\n",
      "tensor(0.0938, grad_fn=<AddBackward0>)\n",
      "3836\n",
      "tensor(0.0967, grad_fn=<AddBackward0>)\n",
      "3838\n",
      "tensor(0.1209, grad_fn=<AddBackward0>)\n",
      "3840\n",
      "tensor(0.0490, grad_fn=<AddBackward0>)\n",
      "3842\n",
      "tensor(0.0467, grad_fn=<AddBackward0>)\n",
      "3844\n",
      "tensor(0.0629, grad_fn=<AddBackward0>)\n",
      "3846\n",
      "tensor(0.0630, grad_fn=<AddBackward0>)\n",
      "3848\n",
      "tensor(0.1029, grad_fn=<AddBackward0>)\n",
      "3850\n",
      "tensor(0.0715, grad_fn=<AddBackward0>)\n",
      "3852\n",
      "tensor(0.0589, grad_fn=<AddBackward0>)\n",
      "3854\n",
      "tensor(0.0783, grad_fn=<AddBackward0>)\n",
      "3856\n",
      "tensor(0.0808, grad_fn=<AddBackward0>)\n",
      "3858\n",
      "tensor(0.0704, grad_fn=<AddBackward0>)\n",
      "3860\n",
      "tensor(0.0730, grad_fn=<AddBackward0>)\n",
      "3862\n",
      "tensor(0.0873, grad_fn=<AddBackward0>)\n",
      "3864\n",
      "tensor(0.0705, grad_fn=<AddBackward0>)\n",
      "3866\n",
      "tensor(0.0674, grad_fn=<AddBackward0>)\n",
      "3868\n",
      "tensor(0.0657, grad_fn=<AddBackward0>)\n",
      "3870\n",
      "tensor(0.0697, grad_fn=<AddBackward0>)\n",
      "3872\n",
      "tensor(0.0674, grad_fn=<AddBackward0>)\n",
      "3874\n",
      "tensor(0.0885, grad_fn=<AddBackward0>)\n",
      "3876\n",
      "tensor(0.0744, grad_fn=<AddBackward0>)\n",
      "3878\n",
      "tensor(0.0932, grad_fn=<AddBackward0>)\n",
      "3880\n",
      "tensor(0.0506, grad_fn=<AddBackward0>)\n",
      "3882\n",
      "tensor(0.0858, grad_fn=<AddBackward0>)\n",
      "3884\n",
      "tensor(0.0600, grad_fn=<AddBackward0>)\n",
      "3886\n",
      "tensor(0.0714, grad_fn=<AddBackward0>)\n",
      "3888\n",
      "tensor(0.0695, grad_fn=<AddBackward0>)\n",
      "3890\n",
      "tensor(0.0485, grad_fn=<AddBackward0>)\n",
      "3892\n",
      "tensor(0.0633, grad_fn=<AddBackward0>)\n",
      "3894\n",
      "tensor(0.0818, grad_fn=<AddBackward0>)\n",
      "3896\n",
      "tensor(0.0596, grad_fn=<AddBackward0>)\n",
      "3898\n",
      "tensor(0.0659, grad_fn=<AddBackward0>)\n",
      "3900\n",
      "tensor(0.0662, grad_fn=<AddBackward0>)\n",
      "3902\n",
      "tensor(0.0447, grad_fn=<AddBackward0>)\n",
      "3904\n",
      "tensor(0.0829, grad_fn=<AddBackward0>)\n",
      "3906\n",
      "tensor(0.0701, grad_fn=<AddBackward0>)\n",
      "3908\n",
      "tensor(0.0724, grad_fn=<AddBackward0>)\n",
      "3910\n",
      "tensor(0.0897, grad_fn=<AddBackward0>)\n",
      "3912\n",
      "tensor(0.0181, grad_fn=<AddBackward0>)\n",
      "3914\n",
      "tensor(0.0896, grad_fn=<AddBackward0>)\n",
      "3916\n",
      "tensor(0.0688, grad_fn=<AddBackward0>)\n",
      "3918\n",
      "tensor(0.0978, grad_fn=<AddBackward0>)\n",
      "3920\n",
      "tensor(0.1106, grad_fn=<AddBackward0>)\n",
      "3922\n",
      "tensor(0.0576, grad_fn=<AddBackward0>)\n",
      "3924\n",
      "tensor(0.0605, grad_fn=<AddBackward0>)\n",
      "3926\n",
      "tensor(0.0632, grad_fn=<AddBackward0>)\n",
      "3928\n",
      "tensor(0.0582, grad_fn=<AddBackward0>)\n",
      "3930\n",
      "tensor(0.0973, grad_fn=<AddBackward0>)\n",
      "3932\n",
      "tensor(0.0115, grad_fn=<AddBackward0>)\n",
      "3934\n",
      "tensor(0.0971, grad_fn=<AddBackward0>)\n",
      "3936\n",
      "tensor(0.0826, grad_fn=<AddBackward0>)\n",
      "3938\n",
      "tensor(0.0803, grad_fn=<AddBackward0>)\n",
      "3940\n",
      "tensor(0.0657, grad_fn=<AddBackward0>)\n",
      "3942\n",
      "tensor(0.0574, grad_fn=<AddBackward0>)\n",
      "3944\n",
      "tensor(0.0497, grad_fn=<AddBackward0>)\n",
      "3946\n",
      "tensor(0.0854, grad_fn=<AddBackward0>)\n",
      "3948\n",
      "tensor(0.0902, grad_fn=<AddBackward0>)\n",
      "3950\n",
      "tensor(0.0669, grad_fn=<AddBackward0>)\n",
      "3952\n",
      "tensor(0.0279, grad_fn=<AddBackward0>)\n",
      "3954\n",
      "tensor(0.0809, grad_fn=<AddBackward0>)\n",
      "3956\n",
      "tensor(0.0885, grad_fn=<AddBackward0>)\n",
      "3958\n",
      "tensor(0.0669, grad_fn=<AddBackward0>)\n",
      "3960\n",
      "tensor(0.0737, grad_fn=<AddBackward0>)\n",
      "3962\n",
      "tensor(0.0761, grad_fn=<AddBackward0>)\n",
      "3964\n",
      "tensor(0.0733, grad_fn=<AddBackward0>)\n",
      "3966\n",
      "tensor(0.0655, grad_fn=<AddBackward0>)\n",
      "3968\n",
      "tensor(0.0474, grad_fn=<AddBackward0>)\n",
      "3970\n",
      "tensor(0.0809, grad_fn=<AddBackward0>)\n",
      "3972\n",
      "tensor(0.0662, grad_fn=<AddBackward0>)\n",
      "3974\n",
      "tensor(0.0767, grad_fn=<AddBackward0>)\n",
      "3976\n",
      "tensor(0.0777, grad_fn=<AddBackward0>)\n",
      "3978\n",
      "tensor(0.0785, grad_fn=<AddBackward0>)\n",
      "3980\n",
      "tensor(0.0612, grad_fn=<AddBackward0>)\n",
      "3982\n",
      "tensor(0.0997, grad_fn=<AddBackward0>)\n",
      "3984\n",
      "tensor(0.1155, grad_fn=<AddBackward0>)\n",
      "3986\n",
      "tensor(0.0782, grad_fn=<AddBackward0>)\n",
      "3988\n",
      "tensor(0.0636, grad_fn=<AddBackward0>)\n",
      "3990\n",
      "tensor(0.0546, grad_fn=<AddBackward0>)\n",
      "3992\n",
      "tensor(0.0819, grad_fn=<AddBackward0>)\n",
      "3994\n",
      "tensor(0.0622, grad_fn=<AddBackward0>)\n",
      "3996\n",
      "tensor(0.0649, grad_fn=<AddBackward0>)\n",
      "3998\n",
      "tensor(0.0732, grad_fn=<AddBackward0>)\n",
      "4000\n",
      "tensor(0.0709, grad_fn=<AddBackward0>)\n",
      "4002\n",
      "tensor(0.0813, grad_fn=<AddBackward0>)\n",
      "4004\n",
      "tensor(0.0592, grad_fn=<AddBackward0>)\n",
      "4006\n",
      "tensor(0.0725, grad_fn=<AddBackward0>)\n",
      "4008\n",
      "tensor(0.0765, grad_fn=<AddBackward0>)\n",
      "4010\n",
      "tensor(0.0655, grad_fn=<AddBackward0>)\n",
      "4012\n",
      "tensor(0.0677, grad_fn=<AddBackward0>)\n",
      "4014\n",
      "tensor(0.0632, grad_fn=<AddBackward0>)\n",
      "4016\n",
      "tensor(0.0682, grad_fn=<AddBackward0>)\n",
      "4018\n",
      "tensor(0.0712, grad_fn=<AddBackward0>)\n",
      "4020\n",
      "tensor(0.0787, grad_fn=<AddBackward0>)\n",
      "4022\n",
      "tensor(0.0944, grad_fn=<AddBackward0>)\n",
      "4024\n",
      "tensor(0.0651, grad_fn=<AddBackward0>)\n",
      "4026\n",
      "tensor(0.0695, grad_fn=<AddBackward0>)\n",
      "4028\n",
      "tensor(0.0760, grad_fn=<AddBackward0>)\n",
      "4030\n",
      "tensor(0.1274, grad_fn=<AddBackward0>)\n",
      "4032\n",
      "tensor(0.0793, grad_fn=<AddBackward0>)\n",
      "4034\n",
      "tensor(0.0723, grad_fn=<AddBackward0>)\n",
      "4036\n",
      "tensor(0.0605, grad_fn=<AddBackward0>)\n",
      "4038\n",
      "tensor(0.0763, grad_fn=<AddBackward0>)\n",
      "4040\n",
      "tensor(0.0683, grad_fn=<AddBackward0>)\n",
      "4042\n",
      "tensor(0.0618, grad_fn=<AddBackward0>)\n",
      "4044\n",
      "tensor(0.0705, grad_fn=<AddBackward0>)\n",
      "4046\n",
      "tensor(0.0801, grad_fn=<AddBackward0>)\n",
      "4048\n",
      "tensor(0.0659, grad_fn=<AddBackward0>)\n",
      "4050\n",
      "tensor(0.0711, grad_fn=<AddBackward0>)\n",
      "4052\n",
      "tensor(0.0567, grad_fn=<AddBackward0>)\n",
      "4054\n",
      "tensor(0.0781, grad_fn=<AddBackward0>)\n",
      "4056\n",
      "tensor(0.0860, grad_fn=<AddBackward0>)\n",
      "4058\n",
      "tensor(0.0579, grad_fn=<AddBackward0>)\n",
      "4060\n",
      "tensor(0.0722, grad_fn=<AddBackward0>)\n",
      "4062\n",
      "tensor(0.0737, grad_fn=<AddBackward0>)\n",
      "4064\n",
      "tensor(0.0654, grad_fn=<AddBackward0>)\n",
      "4066\n",
      "tensor(0.0783, grad_fn=<AddBackward0>)\n",
      "4068\n",
      "tensor(0.0868, grad_fn=<AddBackward0>)\n",
      "4070\n",
      "tensor(0.0807, grad_fn=<AddBackward0>)\n",
      "4072\n",
      "tensor(0.0863, grad_fn=<AddBackward0>)\n",
      "4074\n",
      "tensor(0.0633, grad_fn=<AddBackward0>)\n",
      "4076\n",
      "tensor(0.0699, grad_fn=<AddBackward0>)\n",
      "4078\n",
      "tensor(0.0743, grad_fn=<AddBackward0>)\n",
      "4080\n",
      "tensor(0.0843, grad_fn=<AddBackward0>)\n",
      "4082\n",
      "tensor(0.0710, grad_fn=<AddBackward0>)\n",
      "4084\n",
      "tensor(0.0720, grad_fn=<AddBackward0>)\n",
      "4086\n",
      "tensor(0.0776, grad_fn=<AddBackward0>)\n",
      "4088\n",
      "tensor(0.0763, grad_fn=<AddBackward0>)\n",
      "4090\n",
      "tensor(0.0689, grad_fn=<AddBackward0>)\n",
      "4092\n",
      "tensor(0.0847, grad_fn=<AddBackward0>)\n",
      "4094\n",
      "tensor(0.0716, grad_fn=<AddBackward0>)\n",
      "4096\n",
      "tensor(0.0687, grad_fn=<AddBackward0>)\n",
      "4098\n",
      "tensor(0.0519, grad_fn=<AddBackward0>)\n",
      "4100\n",
      "tensor(0.0663, grad_fn=<AddBackward0>)\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[11], line 43\u001b[0m\n\u001b[1;32m     41\u001b[0m pc_B\u001b[39m=\u001b[39mnp\u001b[39m.\u001b[39mzeros([\u001b[39m3\u001b[39m,pc_size])\n\u001b[1;32m     42\u001b[0m \u001b[39mfor\u001b[39;00m i \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(pc_size):\n\u001b[0;32m---> 43\u001b[0m     R\u001b[39m=\u001b[39mRotation\u001b[39m.\u001b[39;49mfrom_euler(\u001b[39m'\u001b[39;49m\u001b[39mzyz\u001b[39;49m\u001b[39m'\u001b[39;49m,[yaw_rnd[i,\u001b[39m0\u001b[39;49m]\u001b[39m*\u001b[39;49m\u001b[39m0\u001b[39;49m,pitch_rnd[i,\u001b[39m0\u001b[39;49m],\u001b[39m0\u001b[39;49m])\n\u001b[1;32m     44\u001b[0m     R\u001b[39m=\u001b[39mR\u001b[39m.\u001b[39mas_matrix()\u001b[39m.\u001b[39mT\n\u001b[1;32m     45\u001b[0m     pc_B[:,i]\u001b[39m=\u001b[39mR \u001b[39m@\u001b[39m np\u001b[39m.\u001b[39marray([range_rnd[i,\u001b[39m0\u001b[39m],\u001b[39m0\u001b[39m,\u001b[39m0\u001b[39m])\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "PI=np.pi\n",
    "\n",
    "#generate training data\n",
    "reward_list=[]\n",
    "reward_sum=0\n",
    "max_pc_size=100\n",
    "input_size=max_pc_size*4+5\n",
    "p=PolicyNetAtt(input_dim=input_size)\n",
    "\n",
    "p.train()\n",
    "for j in range(100000):\n",
    "#agent state\n",
    "    half_fov=PI/4\n",
    "    yaw=0\n",
    "    pitch=np.random.uniform(-PI/4,PI/4)\n",
    "    vx=np.random.uniform(-2,2)\n",
    "    vy=np.random.uniform(-2,2)\n",
    "    vz=np.random.uniform(-2,2)\n",
    "\n",
    "    #pointcloud\n",
    "    import time\n",
    "\n",
    "    t0=time.time()\n",
    "\n",
    "    \n",
    "\n",
    "    pc_size=int(np.random.uniform(1,max_pc_size))\n",
    "    #pc_size=1\n",
    "\n",
    "\n",
    "    #generate random pointcloud w.r.t body\n",
    "    yaw_rnd=np.random.uniform(yaw-half_fov,yaw+half_fov,(pc_size,1))\n",
    "    pitch_rnd=np.random.uniform(pitch-half_fov,pitch+half_fov,(pc_size,1))\n",
    "    range_rnd=np.random.normal(3,1,(pc_size,1))\n",
    "\n",
    "\n",
    "\n",
    "    from scipy.spatial.transform import Rotation\n",
    "\n",
    "    pc_B=np.zeros([3,pc_size])\n",
    "    for i in range(pc_size):\n",
    "        R=Rotation.from_euler('zyz',[yaw_rnd[i,0]*0,pitch_rnd[i,0],0])\n",
    "        R=R.as_matrix().T\n",
    "        pc_B[:,i]=R @ np.array([range_rnd[i,0],0,0])\n",
    "\n",
    "\n",
    "\n",
    "    #numpy to torch\n",
    "\n",
    "    agent_state=torch.Tensor(np.hstack([yaw,pitch,vx,vy,vz]))\n",
    "    pc_B=torch.Tensor(pc_B)\n",
    "    padding=torch.zeros(3*(max_pc_size-pc_size))\n",
    "    mask=torch.tensor([True]*pc_size+[False]*(max_pc_size-pc_size))\n",
    "\n",
    "    #network input\n",
    "    net_input=torch.hstack((agent_state,pc_B.flatten(),padding,mask))\n",
    "\n",
    "    \n",
    "    u=p.forward(net_input)\n",
    "\n",
    "    dt=0.1\n",
    "    w=u*dt\n",
    "    \n",
    "    \n",
    "    \n",
    "    agent_state[:2]=agent_state[:2]+u*dt\n",
    "    pc_B_next=pc_B-agent_state[2:].reshape(3,1)*dt\n",
    "\n",
    "\n",
    "    R_B_C=zy_rotation_matrix(angle_z=agent_state[0],angle_y=agent_state[1])\n",
    "\n",
    "    pc_C_next=R_B_C @ pc_B_next\n",
    "        \n",
    "    reward=(1-calculate_pc_reward(pc_C_next)/pc_size)\n",
    "    \n",
    "    if j%2==0:\n",
    "        print(j)\n",
    "        #print(calculate_reward(agent_state))\n",
    "        #print(calculate_reward(agent_state,pc_B_next))\n",
    "        print(reward_sum)\n",
    "        reward_list.append(np.float(reward_sum))\n",
    "        reward_sum=0\n",
    "    else:\n",
    "        reward_sum+=reward\n",
    "\n",
    "    reward.backward()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "phi_pc_C=torch.FloatTensor(pc_size,1).uniform_(-self.fov,self.fov)\n",
    "psi_pc_C=torch.FloatTensor(pc_size,1).uniform_(-self.fov,self.fov)\n",
    "range_pc_C=torch.FloatTensor(pc_size,1).uniform_(1,3)\n",
    "\n",
    "x_pc_C=range_pc_C*torch.cos(phi_pc_C)*torch.cos(psi_pc_C)\n",
    "y_pc_C=range_pc_C*torch.sin(phi_pc_C)*torch.cos(psi_pc_C)\n",
    "z_pc_C=range_pc_C*torch.sin(psi_pc_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 632,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "tensor(-0.6959, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "1\n",
      "tensor(-0.7115, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "2\n",
      "tensor(-0.7088, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "3\n",
      "tensor(-0.7105, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "4\n",
      "tensor(-0.6868, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "5\n",
      "tensor(-0.7078, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "6\n",
      "tensor(-0.7775, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "7\n",
      "tensor(-0.7342, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "8\n",
      "tensor(-0.7143, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "9\n",
      "tensor(-0.7430, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "10\n",
      "tensor(-0.6840, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "11\n",
      "tensor(-0.7372, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "12\n",
      "tensor(-0.7098, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "13\n",
      "tensor(-0.6866, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "14\n",
      "tensor(-0.7462, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "15\n",
      "tensor(-0.7420, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "16\n",
      "tensor(-0.7153, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "17\n",
      "tensor(-0.7040, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "18\n",
      "tensor(-0.7353, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "19\n",
      "tensor(-0.7454, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "20\n",
      "tensor(-0.7298, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "21\n",
      "tensor(-0.7335, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "22\n",
      "tensor(-0.7654, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "23\n",
      "tensor(-0.7136, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "24\n",
      "tensor(-0.7336, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "25\n",
      "tensor(-0.7371, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "26\n",
      "tensor(-0.7395, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "27\n",
      "tensor(-0.7568, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "28\n",
      "tensor(-0.7341, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "29\n",
      "tensor(-0.7288, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "30\n",
      "tensor(-0.7185, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "31\n",
      "tensor(-0.7406, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "32\n",
      "tensor(-0.7655, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "33\n",
      "tensor(-0.7072, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "34\n",
      "tensor(-0.7571, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "35\n",
      "tensor(-0.7296, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "36\n",
      "tensor(-0.7273, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "37\n",
      "tensor(-0.7636, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "38\n",
      "tensor(-0.7288, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "39\n",
      "tensor(-0.7961, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "40\n",
      "tensor(-0.7953, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "41\n",
      "tensor(-0.7336, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "42\n",
      "tensor(-0.7325, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "43\n",
      "tensor(-0.7393, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "44\n",
      "tensor(-0.7855, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "45\n",
      "tensor(-0.7539, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "46\n",
      "tensor(-0.7756, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "47\n",
      "tensor(-0.7560, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "48\n",
      "tensor(-0.7723, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "49\n",
      "tensor(-0.7792, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "50\n",
      "tensor(-0.7844, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "51\n",
      "tensor(-0.7787, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "52\n",
      "tensor(-0.7862, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "53\n",
      "tensor(-0.8164, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "54\n",
      "tensor(-0.8112, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "55\n",
      "tensor(-0.7984, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "56\n",
      "tensor(-0.8059, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "57\n",
      "tensor(-0.8338, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "58\n",
      "tensor(-0.7907, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "59\n",
      "tensor(-0.7905, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "60\n",
      "tensor(-0.8145, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "61\n",
      "tensor(-0.8298, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "62\n",
      "tensor(-0.8190, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "63\n",
      "tensor(-0.8263, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "64\n",
      "tensor(-0.8163, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "65\n",
      "tensor(-0.8192, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "66\n",
      "tensor(-0.8351, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "67\n",
      "tensor(-0.8242, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "68\n",
      "tensor(-0.8323, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "69\n",
      "tensor(-0.8265, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "70\n",
      "tensor(-0.8325, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "71\n",
      "tensor(-0.8638, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "72\n",
      "tensor(-0.8602, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "73\n",
      "tensor(-0.8511, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "74\n",
      "tensor(-0.8559, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "75\n",
      "tensor(-0.8795, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "76\n",
      "tensor(-0.8484, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "77\n",
      "tensor(-0.8731, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "78\n",
      "tensor(-0.8571, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "79\n",
      "tensor(-0.8876, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "80\n",
      "tensor(-0.8609, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "81\n",
      "tensor(-0.8759, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "82\n",
      "tensor(-0.8947, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "83\n",
      "tensor(-0.8824, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "84\n",
      "tensor(-0.8942, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "85\n",
      "tensor(-0.9041, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "86\n",
      "tensor(-0.8814, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "87\n",
      "tensor(-0.8762, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "88\n",
      "tensor(-0.9135, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "89\n",
      "tensor(-0.9013, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "90\n",
      "tensor(-0.8966, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "91\n",
      "tensor(-0.8961, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "92\n",
      "tensor(-0.8996, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "93\n",
      "tensor(-0.8943, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "94\n",
      "tensor(-0.9186, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "95\n",
      "tensor(-0.8924, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "96\n",
      "tensor(-0.9037, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "97\n",
      "tensor(-0.9176, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "98\n",
      "tensor(-0.9063, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "99\n",
      "tensor(-0.9101, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "100\n",
      "tensor(-0.9006, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "101\n",
      "tensor(-0.8982, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "102\n",
      "tensor(-0.9127, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "103\n",
      "tensor(-0.9278, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "104\n",
      "tensor(-0.9171, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "105\n",
      "tensor(-0.9247, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "106\n",
      "tensor(-0.9095, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "107\n",
      "tensor(-0.9169, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "108\n",
      "tensor(-0.9156, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "109\n",
      "tensor(-0.9354, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "110\n",
      "tensor(-0.9099, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "111\n",
      "tensor(-0.9379, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "112\n",
      "tensor(-0.9137, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "113\n",
      "tensor(-0.9142, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "114\n",
      "tensor(-0.9212, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "115\n",
      "tensor(-0.9533, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "116\n",
      "tensor(-0.9291, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "117\n",
      "tensor(-0.9237, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "118\n",
      "tensor(-0.9310, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "119\n",
      "tensor(-0.9215, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "120\n",
      "tensor(-0.9141, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "121\n",
      "tensor(-0.9301, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "122\n",
      "tensor(-0.9269, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "123\n",
      "tensor(-0.9466, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "124\n",
      "tensor(-0.9223, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "125\n",
      "tensor(-0.9207, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "126\n",
      "tensor(-0.9628, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "127\n",
      "tensor(-0.9359, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "128\n",
      "tensor(-0.9548, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "129\n",
      "tensor(-0.9352, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "130\n",
      "tensor(-0.9544, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "131\n",
      "tensor(-0.9598, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "132\n",
      "tensor(-0.9511, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "133\n",
      "tensor(-0.9454, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "134\n",
      "tensor(-0.9491, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "135\n",
      "tensor(-0.9486, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "136\n",
      "tensor(-0.9572, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "137\n",
      "tensor(-0.9549, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "138\n",
      "tensor(-0.9743, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "139\n",
      "tensor(-0.9445, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "140\n",
      "tensor(-0.9582, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "141\n",
      "tensor(-0.9775, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "142\n",
      "tensor(-0.9641, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "143\n",
      "tensor(-0.9674, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "144\n",
      "tensor(-0.9628, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "145\n",
      "tensor(-0.9805, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "146\n",
      "tensor(-0.9359, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "147\n",
      "tensor(-0.9603, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "148\n",
      "tensor(-0.9631, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "149\n",
      "tensor(-0.9519, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "150\n",
      "tensor(-0.9407, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "151\n",
      "tensor(-0.9481, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "152\n",
      "tensor(-0.9626, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "153\n",
      "tensor(-0.9650, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "154\n",
      "tensor(-0.9469, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "155\n",
      "tensor(-0.9791, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "156\n",
      "tensor(-0.9914, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "157\n",
      "tensor(-0.9725, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "158\n",
      "tensor(-0.9665, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "159\n",
      "tensor(-0.9647, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "160\n",
      "tensor(-0.9695, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "161\n",
      "tensor(-0.9665, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "162\n",
      "tensor(-0.9457, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "163\n",
      "tensor(-0.9656, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "164\n",
      "tensor(-0.9420, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "165\n",
      "tensor(-0.9829, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "166\n",
      "tensor(-0.9492, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "167\n",
      "tensor(-0.9616, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "168\n",
      "tensor(-0.9446, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "169\n",
      "tensor(-0.9532, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "170\n",
      "tensor(-0.9470, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "171\n",
      "tensor(-0.9793, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "172\n",
      "tensor(-0.9676, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "173\n",
      "tensor(-0.9736, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "174\n",
      "tensor(-0.9903, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "175\n",
      "tensor(-0.9708, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "176\n",
      "tensor(-0.9616, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "177\n",
      "tensor(-0.9958, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "178\n",
      "tensor(-1.0074, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "179\n",
      "tensor(-0.9489, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "180\n",
      "tensor(-0.9616, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "181\n",
      "tensor(-0.9793, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "182\n",
      "tensor(-0.9639, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "183\n",
      "tensor(-0.9829, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "184\n",
      "tensor(-0.9541, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "185\n",
      "tensor(-0.9845, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "186\n",
      "tensor(-0.9867, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "187\n",
      "tensor(-0.9693, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "188\n",
      "tensor(-0.9623, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "189\n",
      "tensor(-0.9797, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "190\n",
      "tensor(-0.9648, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "191\n",
      "tensor(-0.9585, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "192\n",
      "tensor(-0.9865, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "193\n",
      "tensor(-0.9620, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "194\n",
      "tensor(-0.9788, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "195\n",
      "tensor(-0.9631, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "196\n",
      "tensor(-0.9627, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "197\n",
      "tensor(-0.9811, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "198\n",
      "tensor(-0.9605, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "199\n",
      "tensor(-1.0053, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "200\n",
      "tensor(-0.9859, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "201\n",
      "tensor(-0.9794, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "202\n",
      "tensor(-0.9882, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "203\n",
      "tensor(-0.9718, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "204\n",
      "tensor(-0.9936, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "205\n",
      "tensor(-0.9490, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "206\n",
      "tensor(-0.9737, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "207\n",
      "tensor(-0.9659, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "208\n",
      "tensor(-0.9750, grad_fn=<DivBackward0>)\n",
      "New best model!\n",
      "209\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "210\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "211\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "212\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "213\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "214\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "215\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "216\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "217\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "218\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "219\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "220\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "221\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "222\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "223\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "224\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "225\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "226\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "227\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "228\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "229\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "230\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "231\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "232\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "233\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "234\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "235\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "236\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "237\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "238\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "239\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "240\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "241\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "242\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "243\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n",
      "244\n",
      "tensor(nan, grad_fn=<DivBackward0>)\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[632], line 84\u001b[0m\n\u001b[1;32m     81\u001b[0m pitch_pc\u001b[39m=\u001b[39mtorch\u001b[39m.\u001b[39mhstack([pitch_pc_1,pitch_pc_2])\n\u001b[1;32m     82\u001b[0m yaw_pc\u001b[39m=\u001b[39mtorch\u001b[39m.\u001b[39mhstack([yaw_pc_1,yaw_pc_2])\n\u001b[0;32m---> 84\u001b[0m bearing\u001b[39m=\u001b[39mtorch\u001b[39m.\u001b[39macos(torch\u001b[39m.\u001b[39;49mcos(pitch_pc)\u001b[39m*\u001b[39;49mtorch\u001b[39m.\u001b[39;49mcos(yaw_pc))\n\u001b[1;32m     86\u001b[0m net_input\u001b[39m=\u001b[39mtorch\u001b[39m.\u001b[39mhstack([pitch_pc,yaw_pc])\n\u001b[1;32m     88\u001b[0m action\u001b[39m=\u001b[39mpolicy\u001b[39m.\u001b[39mforward(net_input)\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "\n",
    "class PolicyNet(nn.Module):\n",
    "\n",
    "    def __init__(self,\n",
    "                 input_dim: int,\n",
    "                 policy_dim: int = 2):\n",
    "\n",
    "        super(PolicyNet, self).__init__()\n",
    "\n",
    "        self.relu = nn.ReLU()\n",
    "        self.tanh = nn.Tanh()\n",
    "\n",
    "        # self.num_landmark = int((input_dim - 3) / 4)\n",
    "        #\n",
    "        # self.agent_pos_fc = nn.Sequential(*[nn.Linear(3, 32), self.relu])\n",
    "        # self.landmark_info_fc = nn.Sequential(*[nn.Linear(self.num_landmark * 2, 32), self.relu])\n",
    "        # self.landmark_pose_fc = nn.Sequential(*[nn.Linear(self.num_landmark * 2, 32), self.relu])\n",
    "        # self.mixer_fc = nn.Sequential(*[nn.Linear(3 * 32, 32), self.relu])\n",
    "        # self.pi_fc = nn.Sequential(*[nn.Linear(32, policy_dim), self.tanh])\n",
    "\n",
    "        # self.fc_1 = nn.Sequential(*[nn.Linear(input_dim, 32), self.relu])\n",
    "        # self.fc_2 = nn.Sequential(*[nn.Linear(32, 64), self.relu])\n",
    "        # self.fc_2 = nn.Sequential(*[nn.Linear(64, 128), self.relu])\n",
    "        # self.fc_3 = nn.Sequential(*[nn.Linear(128, 64), self.relu])\n",
    "        # self.fc_3 = nn.Sequential(*[nn.Linear(64, 32), self.relu])\n",
    "        # self.pi_fc = nn.Sequential(*[nn.Linear(32, policy_dim), self.tanh])\n",
    "\n",
    "        layers = []\n",
    "        layers += [nn.Linear(input_dim, int(input_dim * 4)), self.relu]\n",
    "        layers += [nn.Linear(int(input_dim * 4), int(input_dim * 8)), self.relu]\n",
    "        layers += [nn.Linear(int(input_dim * 8), int(input_dim * 12)), self.relu]\n",
    "        layers += [nn.Linear(int(input_dim * 12), int(input_dim * 8)), self.relu]\n",
    "        layers += [nn.Linear(int(input_dim * 8), int(input_dim * 4)), self.relu]\n",
    "        layers += [nn.Linear(int(input_dim * 4), policy_dim), self.tanh]\n",
    "        self.pi = nn.Sequential(*layers)\n",
    "\n",
    "    def forward(self, observation: torch.Tensor) -> torch.Tensor:\n",
    "        if len(observation.size()) == 1:\n",
    "            observation = observation[None, :]\n",
    "\n",
    "        # mixer_input = torch.cat((self.agent_pos_fc(observation[:, :3]).squeeze(),\n",
    "        #                          self.landmark_info_fc(observation[:, 3:3 + 2 * self.num_landmark]).squeeze(),\n",
    "        #                          self.landmark_pose_fc(observation[:, 3 + 2 * self.num_landmark:]).squeeze()))\n",
    "\n",
    "        # action = self.pi_fc(self.mixer_fc(mixer_input))\n",
    "\n",
    "        # action = self.pi_fc(self.fc_3(self.fc_2(self.fc_1(observation))))\n",
    "\n",
    "        action = self.pi(observation)\n",
    "\n",
    "        if action.size()[0] == 1:\n",
    "            action = action.flatten()\n",
    "\n",
    "        #scaled_action = torch.hstack(((1 + action[0]) / 2 * 1.0, action[1] * 0.1))\n",
    "        scaled_action=action\n",
    "        return scaled_action\n",
    "    \n",
    "pc_size=128\n",
    "\n",
    "policy=PolicyNet(input_dim=pc_size*2)\n",
    "\n",
    "policy_optimizer=Adam(policy.parameters(),lr=0.000003)\n",
    "policy.train()\n",
    "r_list=[]\n",
    "for i in range(660):\n",
    "    policy_optimizer.zero_grad()\n",
    "    r_sum=0\n",
    "    \n",
    "    for j in range(100):\n",
    "        \n",
    "        mu_pitch_pc=torch.Tensor(pc_size).uniform_(-np.pi/2,np.pi/2)[0]\n",
    "        mu_yaw_pc=torch.Tensor(pc_size).uniform_(-np.pi,np.pi)[0]\n",
    "        \n",
    "\n",
    "\n",
    "        pitch_pc_1=torch.Tensor(int(pc_size/2)).normal_(mean=mu_pitch_pc,std=0.1)\n",
    "        yaw_pc_1=torch.Tensor(int(pc_size/2)).normal_(mean=mu_yaw_pc,std=0.1)\n",
    "        \n",
    "        pitch_pc_2=torch.Tensor(int(pc_size/2)).normal_(mean=-mu_pitch_pc,std=0.1)\n",
    "        yaw_pc_2=torch.Tensor(int(pc_size/2)).normal_(mean=-mu_yaw_pc,std=0.1)\n",
    "        \n",
    "        pitch_pc=torch.hstack([pitch_pc_1,pitch_pc_2])\n",
    "        yaw_pc=torch.hstack([yaw_pc_1,yaw_pc_2])\n",
    "        \n",
    "        bearing=torch.acos(torch.cos(pitch_pc)*torch.cos(yaw_pc))\n",
    "        \n",
    "        net_input=torch.hstack([pitch_pc,yaw_pc])\n",
    "        \n",
    "        action=policy.forward(net_input)\n",
    "        pitch_pc_next=pitch_pc+action[0]*1.57\n",
    "        yaw_pc_next=yaw_pc+action[1]*3.14\n",
    "        bearing_next=torch.acos(torch.cos(pitch_pc_next)*torch.cos(yaw_pc_next))\n",
    "        \n",
    "        \n",
    "        a=1.0\n",
    "        fov=np.pi/2\n",
    "        b=bearing_next\n",
    "        v=1/(1+torch.exp(-a*torch.cos(np.pi*b/2/fov)))\n",
    "        r=torch.log(1-torch.mean(v))\n",
    "        r.backward()\n",
    "        \n",
    "        r_sum+=r\n",
    "    print(i)\n",
    "    print(r_sum/100)\n",
    "    if(r_sum/100<0.3):\n",
    "        print(\"New best model!\")\n",
    "        torch.save(policy.state_dict(), './checkpoints/model_info_5_moving_landmarks_2.pth')\n",
    "    r_list.append(r_sum.detach().numpy()/100)\n",
    "    r_sum=0\n",
    "    policy_optimizer.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7943282347242815"
      ]
     },
     "execution_count": 262,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10**(-0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 633,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f2d7ce7dfa0>]"
      ]
     },
     "execution_count": 633,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.plot(r_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 647,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(0.4667, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5666, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0241, 0.6137], grad_fn=<MulBackward0>)\n",
      "tensor(0.6762, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7171, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0215,  1.0745], grad_fn=<MulBackward0>)\n",
      "tensor(0.5004, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5007, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0446,  0.5948], grad_fn=<MulBackward0>)\n",
      "tensor(0.5278, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4837, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0317,  1.2357], grad_fn=<MulBackward0>)\n",
      "tensor(0.2818, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2838, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0076, 0.0358], grad_fn=<MulBackward0>)\n",
      "tensor(0.6175, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6285, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0204, 1.1375], grad_fn=<MulBackward0>)\n",
      "tensor(0.6074, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4043, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1054,  1.0173], grad_fn=<MulBackward0>)\n",
      "tensor(0.6136, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6372, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0163, 1.0968], grad_fn=<MulBackward0>)\n",
      "tensor(0.5168, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4875, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0430,  1.1821], grad_fn=<MulBackward0>)\n",
      "tensor(0.4646, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5842, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0015,  0.6211], grad_fn=<MulBackward0>)\n",
      "tensor(0.3398, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3870, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0094, 0.2728], grad_fn=<MulBackward0>)\n",
      "tensor(0.7043, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5537, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0059,  1.3711], grad_fn=<MulBackward0>)\n",
      "tensor(0.6665, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6022, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0303,  1.2822], grad_fn=<MulBackward0>)\n",
      "tensor(0.4217, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3589, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0688,  0.5520], grad_fn=<MulBackward0>)\n",
      "tensor(0.6465, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4320, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0443,  1.1795], grad_fn=<MulBackward0>)\n",
      "tensor(0.4993, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4132, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1031,  0.8038], grad_fn=<MulBackward0>)\n",
      "tensor(0.3044, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3215, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0080, 0.1460], grad_fn=<MulBackward0>)\n",
      "tensor(0.5086, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3641, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0936,  0.7596], grad_fn=<MulBackward0>)\n",
      "tensor(0.6074, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3936, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0501,  1.0062], grad_fn=<MulBackward0>)\n",
      "tensor(0.4970, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4976, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0236, 0.4981], grad_fn=<MulBackward0>)\n",
      "tensor(0.6530, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4996, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0690,  1.4587], grad_fn=<MulBackward0>)\n",
      "tensor(0.5321, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6766, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0076,  0.7319], grad_fn=<MulBackward0>)\n",
      "tensor(0.4697, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5714, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0149, 0.6422], grad_fn=<MulBackward0>)\n",
      "tensor(0.7135, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5576, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0127,  1.3717], grad_fn=<MulBackward0>)\n",
      "tensor(0.5912, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3979, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0352,  0.9645], grad_fn=<MulBackward0>)\n",
      "tensor(0.5457, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4685, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1538,  1.1526], grad_fn=<MulBackward0>)\n",
      "tensor(0.4066, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4996, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0262, 0.4585], grad_fn=<MulBackward0>)\n",
      "tensor(0.4681, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4291, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0356,  0.6635], grad_fn=<MulBackward0>)\n",
      "tensor(0.5211, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4877, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1519,  1.2394], grad_fn=<MulBackward0>)\n",
      "tensor(0.4610, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5242, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0152, 0.6311], grad_fn=<MulBackward0>)\n",
      "tensor(0.6610, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4551, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0530,  1.2611], grad_fn=<MulBackward0>)\n",
      "tensor(0.3186, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2998, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0332,  0.2229], grad_fn=<MulBackward0>)\n",
      "tensor(0.6179, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4396, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1225,  1.1272], grad_fn=<MulBackward0>)\n",
      "tensor(0.6744, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4771, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0652,  1.3403], grad_fn=<MulBackward0>)\n",
      "tensor(0.3366, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3323, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0222,  0.2140], grad_fn=<MulBackward0>)\n",
      "tensor(0.3318, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2959, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0072,  0.2959], grad_fn=<MulBackward0>)\n",
      "tensor(0.5727, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3741, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0555,  0.8791], grad_fn=<MulBackward0>)\n",
      "tensor(0.5194, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4862, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0481,  1.1912], grad_fn=<MulBackward0>)\n",
      "tensor(0.5427, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3930, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0278,  0.9023], grad_fn=<MulBackward0>)\n",
      "tensor(0.3929, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3324, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0689,  0.4614], grad_fn=<MulBackward0>)\n",
      "tensor(0.3868, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4822, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0066,  0.4130], grad_fn=<MulBackward0>)\n",
      "tensor(0.6949, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6248, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0243,  1.2668], grad_fn=<MulBackward0>)\n",
      "tensor(0.4200, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5230, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0051, 0.4757], grad_fn=<MulBackward0>)\n",
      "tensor(0.3325, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3555, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0051,  0.2142], grad_fn=<MulBackward0>)\n",
      "tensor(0.3709, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4193, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0075,  0.3455], grad_fn=<MulBackward0>)\n",
      "tensor(0.5803, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4541, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1353,  1.1342], grad_fn=<MulBackward0>)\n",
      "tensor(0.3376, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3912, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0170, 0.2887], grad_fn=<MulBackward0>)\n",
      "tensor(0.3964, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3277, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0428,  0.4775], grad_fn=<MulBackward0>)\n",
      "tensor(0.5417, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6674, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0043,  0.7937], grad_fn=<MulBackward0>)\n",
      "tensor(0.5058, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6454, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0030,  0.6944], grad_fn=<MulBackward0>)\n",
      "tensor(0.6561, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4098, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0719,  1.0931], grad_fn=<MulBackward0>)\n",
      "tensor(0.6587, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7061, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0105,  1.0661], grad_fn=<MulBackward0>)\n",
      "tensor(0.4794, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4847, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0478,  0.4782], grad_fn=<MulBackward0>)\n",
      "tensor(0.5785, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4652, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0554,  1.2377], grad_fn=<MulBackward0>)\n",
      "tensor(0.6387, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5750, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0076, 1.2904], grad_fn=<MulBackward0>)\n",
      "tensor(0.3687, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3629, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0377,  0.3019], grad_fn=<MulBackward0>)\n",
      "tensor(0.3252, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2975, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0060,  0.2636], grad_fn=<MulBackward0>)\n",
      "tensor(0.6087, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3844, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0641,  0.9676], grad_fn=<MulBackward0>)\n",
      "tensor(0.7129, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6601, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0157,  1.2225], grad_fn=<MulBackward0>)\n",
      "tensor(0.5319, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3610, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0501,  0.7870], grad_fn=<MulBackward0>)\n",
      "tensor(0.7153, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4756, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1072,  1.3087], grad_fn=<MulBackward0>)\n",
      "tensor(0.3501, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3503, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0474,  0.2371], grad_fn=<MulBackward0>)\n",
      "tensor(0.5702, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6414, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0189,  0.9565], grad_fn=<MulBackward0>)\n",
      "tensor(0.4686, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5795, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0165,  0.6278], grad_fn=<MulBackward0>)\n",
      "tensor(0.5126, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4945, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0481,  1.2964], grad_fn=<MulBackward0>)\n",
      "tensor(0.5504, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4049, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0975,  0.9086], grad_fn=<MulBackward0>)\n",
      "tensor(0.4872, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5146, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0066,  0.7064], grad_fn=<MulBackward0>)\n",
      "tensor(0.5409, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6534, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0070,  0.8154], grad_fn=<MulBackward0>)\n",
      "tensor(0.4727, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4932, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0133, 0.5559], grad_fn=<MulBackward0>)\n",
      "tensor(0.5498, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3779, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0241,  0.8795], grad_fn=<MulBackward0>)\n",
      "tensor(0.4916, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4678, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0506,  0.7716], grad_fn=<MulBackward0>)\n",
      "tensor(0.5847, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3829, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0760,  0.9075], grad_fn=<MulBackward0>)\n",
      "tensor(0.3987, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4392, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0055, 0.3899], grad_fn=<MulBackward0>)\n",
      "tensor(0.5749, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4328, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1280,  1.0311], grad_fn=<MulBackward0>)\n",
      "tensor(0.7110, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5137, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1373,  1.4506], grad_fn=<MulBackward0>)\n",
      "tensor(0.4100, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4933, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0225,  0.4635], grad_fn=<MulBackward0>)\n",
      "tensor(0.2956, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3095, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0030,  0.1245], grad_fn=<MulBackward0>)\n",
      "tensor(0.2737, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2737, grad_fn=<RsubBackward1>)\n",
      "tensor([ 1.1528e-02, -8.5912e-05], grad_fn=<MulBackward0>)\n",
      "tensor(0.2985, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3001, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0007, 0.0736], grad_fn=<MulBackward0>)\n",
      "tensor(0.5192, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4986, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1895,  1.4627], grad_fn=<MulBackward0>)\n",
      "tensor(0.3520, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4165, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0037, 0.3249], grad_fn=<MulBackward0>)\n",
      "tensor(0.5940, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4875, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1751,  1.3886], grad_fn=<MulBackward0>)\n",
      "tensor(0.3759, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3090, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0073,  0.4437], grad_fn=<MulBackward0>)\n",
      "tensor(0.2971, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2989, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0196, 0.0823], grad_fn=<MulBackward0>)\n",
      "tensor(0.2993, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2880, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0028, 0.1368], grad_fn=<MulBackward0>)\n",
      "tensor(0.7034, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5111, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0951,  1.4635], grad_fn=<MulBackward0>)\n",
      "tensor(0.2812, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2815, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0250, 0.0203], grad_fn=<MulBackward0>)\n",
      "tensor(0.6804, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5052, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0618,  1.4535], grad_fn=<MulBackward0>)\n",
      "tensor(0.4248, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5054, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0344, 0.4981], grad_fn=<MulBackward0>)\n",
      "tensor(0.5444, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5762, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0341,  1.0276], grad_fn=<MulBackward0>)\n",
      "tensor(0.6585, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6315, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0177,  1.2229], grad_fn=<MulBackward0>)\n",
      "tensor(0.6384, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6818, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0112, 1.0583], grad_fn=<MulBackward0>)\n",
      "tensor(0.6786, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6587, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0063,  1.1906], grad_fn=<MulBackward0>)\n",
      "tensor(0.6600, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4331, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0672,  1.1674], grad_fn=<MulBackward0>)\n",
      "tensor(0.5578, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5146, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0146, 1.4025], grad_fn=<MulBackward0>)\n",
      "tensor(0.2992, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3069, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0101, 0.0997], grad_fn=<MulBackward0>)\n",
      "tensor(0.7036, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5993, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0226,  1.3131], grad_fn=<MulBackward0>)\n",
      "tensor(0.5003, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5913, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0120,  0.7311], grad_fn=<MulBackward0>)\n",
      "tensor(0.2820, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2828, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0072,  0.0317], grad_fn=<MulBackward0>)\n",
      "tensor(0.6725, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5022, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0758,  1.4559], grad_fn=<MulBackward0>)\n",
      "tensor(0.6135, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6781, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0064,  1.0281], grad_fn=<MulBackward0>)\n",
      "tensor(0.5125, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3992, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0278,  0.8262], grad_fn=<MulBackward0>)\n",
      "tensor(0.5499, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6062, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0219,  0.9813], grad_fn=<MulBackward0>)\n",
      "tensor(0.5552, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4745, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0370,  1.2573], grad_fn=<MulBackward0>)\n",
      "tensor(0.3975, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4248, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0239, 0.3709], grad_fn=<MulBackward0>)\n",
      "tensor(0.3211, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3579, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0128, 0.2254], grad_fn=<MulBackward0>)\n",
      "tensor(0.5807, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3960, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0300,  0.9587], grad_fn=<MulBackward0>)\n",
      "tensor(0.5131, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4950, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1644,  1.3165], grad_fn=<MulBackward0>)\n",
      "tensor(0.4984, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5837, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0089,  0.7414], grad_fn=<MulBackward0>)\n",
      "tensor(0.5996, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4145, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0520,  1.0697], grad_fn=<MulBackward0>)\n",
      "tensor(0.5051, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5423, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0209, 0.8590], grad_fn=<MulBackward0>)\n",
      "tensor(0.5881, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6968, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0104, 0.8834], grad_fn=<MulBackward0>)\n",
      "tensor(0.6472, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7145, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0065,  1.0210], grad_fn=<MulBackward0>)\n",
      "tensor(0.3357, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3775, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0259, 0.2584], grad_fn=<MulBackward0>)\n",
      "tensor(0.3763, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3873, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0608,  0.3023], grad_fn=<MulBackward0>)\n",
      "tensor(0.5152, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5383, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0119,  0.9796], grad_fn=<MulBackward0>)\n",
      "tensor(0.4248, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4010, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1037,  0.5087], grad_fn=<MulBackward0>)\n",
      "tensor(0.5530, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6524, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0150, 0.8605], grad_fn=<MulBackward0>)\n",
      "tensor(0.5972, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6199, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0123, 1.1183], grad_fn=<MulBackward0>)\n",
      "tensor(0.5043, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4806, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1418,  0.9729], grad_fn=<MulBackward0>)\n",
      "tensor(0.4592, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5992, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0074,  0.5864], grad_fn=<MulBackward0>)\n",
      "tensor(0.4088, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4052, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0864,  0.3842], grad_fn=<MulBackward0>)\n",
      "tensor(0.4182, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5311, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0038, 0.4948], grad_fn=<MulBackward0>)\n",
      "tensor(0.4811, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4908, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0388,  0.5444], grad_fn=<MulBackward0>)\n",
      "tensor(0.4776, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4328, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1065,  0.7408], grad_fn=<MulBackward0>)\n",
      "tensor(0.2730, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2733, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0236, 0.0074], grad_fn=<MulBackward0>)\n",
      "tensor(0.6271, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7183, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0034,  0.9496], grad_fn=<MulBackward0>)\n",
      "tensor(0.4093, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3242, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0546,  0.5248], grad_fn=<MulBackward0>)\n",
      "tensor(0.7191, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5034, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0806,  1.4160], grad_fn=<MulBackward0>)\n",
      "tensor(0.5058, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4928, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1467,  1.1179], grad_fn=<MulBackward0>)\n",
      "tensor(0.4024, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4763, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0165, 0.4377], grad_fn=<MulBackward0>)\n",
      "tensor(0.4618, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5982, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0071, 0.5854], grad_fn=<MulBackward0>)\n",
      "tensor(0.4040, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3425, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0067,  0.4928], grad_fn=<MulBackward0>)\n",
      "tensor(0.5429, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4821, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0473,  1.2644], grad_fn=<MulBackward0>)\n",
      "tensor(0.7095, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6712, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0127,  1.2103], grad_fn=<MulBackward0>)\n",
      "tensor(0.3333, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3550, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0221, 0.2137], grad_fn=<MulBackward0>)\n",
      "tensor(0.4786, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4983, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0084,  0.6061], grad_fn=<MulBackward0>)\n",
      "tensor(0.3742, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4061, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0055, 0.3273], grad_fn=<MulBackward0>)\n",
      "tensor(0.5765, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5408, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0396,  1.3222], grad_fn=<MulBackward0>)\n",
      "tensor(0.5137, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5896, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0192, 0.7986], grad_fn=<MulBackward0>)\n",
      "tensor(0.2870, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2906, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0133, 0.0587], grad_fn=<MulBackward0>)\n",
      "tensor(0.4355, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4928, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0108, 0.5216], grad_fn=<MulBackward0>)\n",
      "tensor(0.3369, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3240, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0458,  0.2468], grad_fn=<MulBackward0>)\n",
      "tensor(0.5486, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3843, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0916,  0.8672], grad_fn=<MulBackward0>)\n",
      "tensor(0.5101, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3494, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0603,  0.7481], grad_fn=<MulBackward0>)\n",
      "tensor(0.5963, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4440, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1384,  1.1431], grad_fn=<MulBackward0>)\n",
      "tensor(0.3410, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3982, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0061, 0.2982], grad_fn=<MulBackward0>)\n",
      "tensor(0.3164, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3256, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0066,  0.1549], grad_fn=<MulBackward0>)\n",
      "tensor(0.4793, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4583, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1294,  0.6930], grad_fn=<MulBackward0>)\n",
      "tensor(0.6455, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4077, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0804,  1.0494], grad_fn=<MulBackward0>)\n",
      "tensor(0.3077, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2940, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0005, 0.1707], grad_fn=<MulBackward0>)\n",
      "tensor(0.4826, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4557, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1041,  0.7463], grad_fn=<MulBackward0>)\n",
      "tensor(0.4549, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5073, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0032, 0.5817], grad_fn=<MulBackward0>)\n",
      "tensor(0.5936, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6319, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0258, 1.0579], grad_fn=<MulBackward0>)\n",
      "tensor(0.2782, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2799, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0198, 0.0305], grad_fn=<MulBackward0>)\n",
      "tensor(0.5676, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6174, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0327,  1.0136], grad_fn=<MulBackward0>)\n",
      "tensor(0.4103, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4823, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0206, 0.4483], grad_fn=<MulBackward0>)\n",
      "tensor(0.4317, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5541, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0058, 0.5247], grad_fn=<MulBackward0>)\n",
      "tensor(0.3385, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3027, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0305,  0.2995], grad_fn=<MulBackward0>)\n",
      "tensor(0.4255, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4343, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0388,  0.3995], grad_fn=<MulBackward0>)\n",
      "tensor(0.4361, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4478, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0286,  0.4039], grad_fn=<MulBackward0>)\n",
      "tensor(0.3335, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3373, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0072,  0.1923], grad_fn=<MulBackward0>)\n",
      "tensor(0.5143, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4693, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0297,  1.0180], grad_fn=<MulBackward0>)\n",
      "tensor(0.7154, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6284, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0172,  1.2764], grad_fn=<MulBackward0>)\n",
      "tensor(0.4562, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5243, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0028,  0.5891], grad_fn=<MulBackward0>)\n",
      "tensor(0.7290, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5246, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1120,  1.4554], grad_fn=<MulBackward0>)\n",
      "tensor(0.6006, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7209, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0168,  0.8616], grad_fn=<MulBackward0>)\n",
      "tensor(0.4435, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5016, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0009, 0.5437], grad_fn=<MulBackward0>)\n",
      "tensor(0.4061, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3538, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0652,  0.5137], grad_fn=<MulBackward0>)\n",
      "tensor(0.5441, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4888, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1606,  1.3263], grad_fn=<MulBackward0>)\n",
      "tensor(0.3404, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3964, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0008, 0.2933], grad_fn=<MulBackward0>)\n",
      "tensor(0.4649, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3929, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0214,  0.6665], grad_fn=<MulBackward0>)\n",
      "tensor(0.4775, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4379, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0351,  0.7001], grad_fn=<MulBackward0>)\n",
      "tensor(0.4892, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4902, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0012,  0.4764], grad_fn=<MulBackward0>)\n",
      "tensor(0.5274, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3878, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0909,  0.8447], grad_fn=<MulBackward0>)\n",
      "tensor(0.5268, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4343, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0475,  0.9412], grad_fn=<MulBackward0>)\n",
      "tensor(0.5068, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3631, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0800,  0.7386], grad_fn=<MulBackward0>)\n",
      "tensor(0.2942, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2838, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0108,  0.1342], grad_fn=<MulBackward0>)\n",
      "tensor(0.5676, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6177, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0165,  1.0072], grad_fn=<MulBackward0>)\n",
      "tensor(0.5482, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4867, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0407,  1.3625], grad_fn=<MulBackward0>)\n",
      "tensor(0.5469, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5376, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0375, 1.2471], grad_fn=<MulBackward0>)\n",
      "tensor(0.6019, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3882, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0539,  0.9511], grad_fn=<MulBackward0>)\n",
      "tensor(0.5564, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3615, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0516,  0.8612], grad_fn=<MulBackward0>)\n",
      "tensor(0.2919, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3014, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0207, 0.1039], grad_fn=<MulBackward0>)\n",
      "tensor(0.2891, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2847, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0033,  0.0939], grad_fn=<MulBackward0>)\n",
      "tensor(0.5724, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3687, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0630,  0.8750], grad_fn=<MulBackward0>)\n",
      "tensor(0.5867, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6028, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0256,  1.1387], grad_fn=<MulBackward0>)\n",
      "tensor(0.6068, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4208, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1249,  1.0521], grad_fn=<MulBackward0>)\n",
      "tensor(0.4582, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4122, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0339,  0.6286], grad_fn=<MulBackward0>)\n",
      "tensor(0.6157, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5300, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0139,  1.3984], grad_fn=<MulBackward0>)\n",
      "tensor(0.3309, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3003, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0266,  0.2691], grad_fn=<MulBackward0>)\n",
      "tensor(0.5698, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6014, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0168,  1.0839], grad_fn=<MulBackward0>)\n",
      "tensor(0.3878, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4555, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0176, 0.4033], grad_fn=<MulBackward0>)\n",
      "tensor(0.5094, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5159, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0274,  1.0835], grad_fn=<MulBackward0>)\n",
      "tensor(0.4899, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4424, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1270,  0.8051], grad_fn=<MulBackward0>)\n",
      "tensor(0.4879, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4928, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0335,  0.5137], grad_fn=<MulBackward0>)\n",
      "tensor(0.4096, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5076, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0210, 0.4569], grad_fn=<MulBackward0>)\n",
      "tensor(0.5389, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3970, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0069,  0.9020], grad_fn=<MulBackward0>)\n",
      "tensor(0.4986, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5766, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0357,  0.7378], grad_fn=<MulBackward0>)\n",
      "tensor(0.5529, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5879, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0327, 1.0254], grad_fn=<MulBackward0>)\n",
      "tensor(0.6801, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6427, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0036,  1.2110], grad_fn=<MulBackward0>)\n",
      "tensor(0.4676, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3622, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0859,  0.6728], grad_fn=<MulBackward0>)\n",
      "tensor(0.4455, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4707, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0158,  0.4924], grad_fn=<MulBackward0>)\n",
      "tensor(0.7021, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4682, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1212,  1.2800], grad_fn=<MulBackward0>)\n",
      "tensor(0.6701, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5920, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0129,  1.3025], grad_fn=<MulBackward0>)\n",
      "tensor(0.6520, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4119, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0902,  1.1038], grad_fn=<MulBackward0>)\n",
      "tensor(0.6847, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6915, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0134,  1.1346], grad_fn=<MulBackward0>)\n",
      "tensor(0.4498, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4984, grad_fn=<RsubBackward1>)\n",
      "tensor([-4.1507e-04,  5.6274e-01], grad_fn=<MulBackward0>)\n",
      "tensor(0.6540, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6966, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0258,  1.0726], grad_fn=<MulBackward0>)\n",
      "tensor(0.3877, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4205, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0127, 0.3583], grad_fn=<MulBackward0>)\n",
      "tensor(0.6433, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5234, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0356,  1.4191], grad_fn=<MulBackward0>)\n",
      "tensor(0.3307, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3383, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0117,  0.1838], grad_fn=<MulBackward0>)\n",
      "tensor(0.6612, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5095, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1733,  1.4719], grad_fn=<MulBackward0>)\n",
      "tensor(0.6303, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4749, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0490,  1.3567], grad_fn=<MulBackward0>)\n",
      "tensor(0.4841, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4850, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0133,  0.4662], grad_fn=<MulBackward0>)\n",
      "tensor(0.3881, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4819, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0066,  0.4076], grad_fn=<MulBackward0>)\n",
      "tensor(0.7067, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5958, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0194,  1.3288], grad_fn=<MulBackward0>)\n",
      "tensor(0.5916, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4178, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1122,  1.0243], grad_fn=<MulBackward0>)\n",
      "tensor(0.4691, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3543, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0088,  0.6761], grad_fn=<MulBackward0>)\n",
      "tensor(0.4559, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4144, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0989,  0.6283], grad_fn=<MulBackward0>)\n",
      "tensor(0.4311, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4699, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0064,  0.4671], grad_fn=<MulBackward0>)\n",
      "tensor(0.6616, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4921, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0773,  1.4397], grad_fn=<MulBackward0>)\n",
      "tensor(0.7156, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4999, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0956,  1.4124], grad_fn=<MulBackward0>)\n",
      "tensor(0.4753, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4986, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0208, 0.6004], grad_fn=<MulBackward0>)\n",
      "tensor(0.6774, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4281, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0926,  1.1597], grad_fn=<MulBackward0>)\n",
      "tensor(0.3935, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4079, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0256,  0.3236], grad_fn=<MulBackward0>)\n",
      "tensor(0.7200, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5199, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1043,  1.4694], grad_fn=<MulBackward0>)\n",
      "tensor(0.4427, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4038, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0226,  0.5742], grad_fn=<MulBackward0>)\n",
      "tensor(0.3748, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3421, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0518,  0.3907], grad_fn=<MulBackward0>)\n",
      "tensor(0.6371, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4866, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1560,  1.3737], grad_fn=<MulBackward0>)\n",
      "tensor(0.4925, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4710, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0448,  0.7607], grad_fn=<MulBackward0>)\n",
      "tensor(0.6155, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4906, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1786,  1.4165], grad_fn=<MulBackward0>)\n",
      "tensor(0.5487, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6491, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0285, 0.8479], grad_fn=<MulBackward0>)\n",
      "tensor(0.5791, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4913, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1741,  1.3924], grad_fn=<MulBackward0>)\n",
      "tensor(0.5154, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5768, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0374, 0.8543], grad_fn=<MulBackward0>)\n",
      "tensor(0.4941, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5876, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0248,  0.7124], grad_fn=<MulBackward0>)\n",
      "tensor(0.6640, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4266, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0704,  1.1030], grad_fn=<MulBackward0>)\n",
      "tensor(0.4682, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3416, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0718,  0.6490], grad_fn=<MulBackward0>)\n",
      "tensor(0.6534, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4276, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0502,  1.1400], grad_fn=<MulBackward0>)\n",
      "tensor(0.4437, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4528, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0395,  0.4189], grad_fn=<MulBackward0>)\n",
      "tensor(0.4910, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4897, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1073,  0.5458], grad_fn=<MulBackward0>)\n",
      "tensor(0.5002, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5926, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0267,  0.7149], grad_fn=<MulBackward0>)\n",
      "tensor(0.5069, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5015, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0346, 1.4339], grad_fn=<MulBackward0>)\n",
      "tensor(0.6562, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6655, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0123, 1.1378], grad_fn=<MulBackward0>)\n",
      "tensor(0.2964, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2948, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0189,  0.0859], grad_fn=<MulBackward0>)\n",
      "tensor(0.4730, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4908, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0267,  0.5603], grad_fn=<MulBackward0>)\n",
      "tensor(0.3974, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3814, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0164,  0.3842], grad_fn=<MulBackward0>)\n",
      "tensor(0.3475, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4106, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0058, 0.3196], grad_fn=<MulBackward0>)\n",
      "tensor(0.5949, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7027, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0026, 0.8889], grad_fn=<MulBackward0>)\n",
      "tensor(0.5116, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4954, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0531,  1.3234], grad_fn=<MulBackward0>)\n",
      "tensor(0.5731, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4417, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0316,  1.1210], grad_fn=<MulBackward0>)\n",
      "tensor(0.3541, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3321, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0111,  0.3005], grad_fn=<MulBackward0>)\n",
      "tensor(0.6371, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6237, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0279,  1.2021], grad_fn=<MulBackward0>)\n",
      "tensor(0.4213, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5097, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0005, 0.4966], grad_fn=<MulBackward0>)\n",
      "tensor(0.5541, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3603, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0408,  0.8548], grad_fn=<MulBackward0>)\n",
      "tensor(0.7206, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5739, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0403,  1.3603], grad_fn=<MulBackward0>)\n",
      "tensor(0.4544, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3623, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0705,  0.6445], grad_fn=<MulBackward0>)\n",
      "tensor(0.6310, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4911, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1698,  1.4021], grad_fn=<MulBackward0>)\n",
      "tensor(0.4977, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4981, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0797,  0.4962], grad_fn=<MulBackward0>)\n",
      "tensor(0.7161, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4959, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0866,  1.3929], grad_fn=<MulBackward0>)\n",
      "tensor(0.6024, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6407, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0256,  1.0626], grad_fn=<MulBackward0>)\n",
      "tensor(0.7163, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4715, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0915,  1.3305], grad_fn=<MulBackward0>)\n",
      "tensor(0.3125, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2922, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0093, 0.2020], grad_fn=<MulBackward0>)\n",
      "tensor(0.3151, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3453, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0059, 0.1987], grad_fn=<MulBackward0>)\n",
      "tensor(0.6078, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5588, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0310, 1.3133], grad_fn=<MulBackward0>)\n",
      "tensor(0.4569, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5265, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0100,  0.5954], grad_fn=<MulBackward0>)\n",
      "tensor(0.7050, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4665, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0849,  1.3059], grad_fn=<MulBackward0>)\n",
      "tensor(0.2886, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2833, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0034, 0.0864], grad_fn=<MulBackward0>)\n",
      "tensor(0.5150, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4119, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1058,  0.8633], grad_fn=<MulBackward0>)\n",
      "tensor(0.6301, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4695, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1524,  1.2813], grad_fn=<MulBackward0>)\n",
      "tensor(0.7017, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6155, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0296,  1.2953], grad_fn=<MulBackward0>)\n",
      "tensor(0.4298, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4527, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0129, 0.4333], grad_fn=<MulBackward0>)\n",
      "tensor(0.4828, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5976, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0251, 0.6580], grad_fn=<MulBackward0>)\n",
      "tensor(0.3007, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2886, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0110, 0.1511], grad_fn=<MulBackward0>)\n",
      "tensor(0.3975, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3348, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0113,  0.4857], grad_fn=<MulBackward0>)\n",
      "tensor(0.5061, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4650, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0365,  0.9234], grad_fn=<MulBackward0>)\n",
      "tensor(0.5045, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6148, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0322, 0.7203], grad_fn=<MulBackward0>)\n",
      "tensor(0.4120, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3201, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0373,  0.5067], grad_fn=<MulBackward0>)\n",
      "tensor(0.5141, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5104, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0236, 1.2735], grad_fn=<MulBackward0>)\n",
      "tensor(0.6363, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4263, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0525,  1.1059], grad_fn=<MulBackward0>)\n",
      "tensor(0.4676, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6013, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0098, 0.5971], grad_fn=<MulBackward0>)\n",
      "tensor(0.3555, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4060, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0037, 0.3150], grad_fn=<MulBackward0>)\n",
      "tensor(0.4902, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4920, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0255, 0.4944], grad_fn=<MulBackward0>)\n",
      "tensor(0.4581, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5045, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0130,  0.5840], grad_fn=<MulBackward0>)\n",
      "tensor(0.7245, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4895, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1067,  1.3943], grad_fn=<MulBackward0>)\n",
      "tensor(0.3324, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3308, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0009, 0.1945], grad_fn=<MulBackward0>)\n",
      "tensor(0.5713, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6787, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0119,  0.8832], grad_fn=<MulBackward0>)\n",
      "tensor(0.3925, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4743, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0008,  0.4105], grad_fn=<MulBackward0>)\n",
      "tensor(0.4673, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4646, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0778,  0.4911], grad_fn=<MulBackward0>)\n",
      "tensor(0.7227, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6031, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0105,  1.3236], grad_fn=<MulBackward0>)\n",
      "tensor(0.5004, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5834, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0224, 0.7495], grad_fn=<MulBackward0>)\n",
      "tensor(0.3920, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3504, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0182,  0.4396], grad_fn=<MulBackward0>)\n",
      "tensor(0.5252, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3867, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0976,  0.8206], grad_fn=<MulBackward0>)\n",
      "tensor(0.4772, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4865, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0167,  0.5088], grad_fn=<MulBackward0>)\n",
      "tensor(0.4034, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3460, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0130,  0.4816], grad_fn=<MulBackward0>)\n",
      "tensor(0.5788, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6863, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0127,  0.8973], grad_fn=<MulBackward0>)\n",
      "tensor(0.2992, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2998, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0133, 0.0903], grad_fn=<MulBackward0>)\n",
      "tensor(0.3555, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4242, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0035, 0.3314], grad_fn=<MulBackward0>)\n",
      "tensor(0.2969, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2872, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0011,  0.1302], grad_fn=<MulBackward0>)\n",
      "tensor(0.5381, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4891, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0261,  1.3494], grad_fn=<MulBackward0>)\n",
      "tensor(0.2801, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2819, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0118, 0.0376], grad_fn=<MulBackward0>)\n",
      "tensor(0.4754, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3463, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0665,  0.6880], grad_fn=<MulBackward0>)\n",
      "tensor(0.6218, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7165, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0192,  0.9466], grad_fn=<MulBackward0>)\n",
      "tensor(0.6871, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4778, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1498,  1.3351], grad_fn=<MulBackward0>)\n",
      "tensor(0.6765, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4875, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1455,  1.3845], grad_fn=<MulBackward0>)\n",
      "tensor(0.5250, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3791, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0933,  0.7996], grad_fn=<MulBackward0>)\n",
      "tensor(0.5001, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5006, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1513,  1.0757], grad_fn=<MulBackward0>)\n",
      "tensor(0.3994, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4994, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0105,  0.4631], grad_fn=<MulBackward0>)\n",
      "tensor(0.6405, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7094, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0015,  1.0047], grad_fn=<MulBackward0>)\n",
      "tensor(0.7009, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6517, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0112,  1.2223], grad_fn=<MulBackward0>)\n",
      "tensor(0.6638, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7175, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0163,  1.0413], grad_fn=<MulBackward0>)\n",
      "tensor(0.4259, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4271, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0709,  0.3990], grad_fn=<MulBackward0>)\n",
      "tensor(0.6182, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6736, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0200,  1.0538], grad_fn=<MulBackward0>)\n",
      "tensor(0.5692, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6091, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0321,  1.0434], grad_fn=<MulBackward0>)\n",
      "tensor(0.6092, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4489, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1353,  1.1864], grad_fn=<MulBackward0>)\n",
      "tensor(0.7227, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5800, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0058,  1.3499], grad_fn=<MulBackward0>)\n",
      "tensor(0.2935, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2830, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0049, 0.1288], grad_fn=<MulBackward0>)\n",
      "tensor(0.4895, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3410, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0524,  0.6888], grad_fn=<MulBackward0>)\n",
      "tensor(0.5690, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5919, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0394,  1.1180], grad_fn=<MulBackward0>)\n",
      "tensor(0.7205, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5140, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0873,  1.4431], grad_fn=<MulBackward0>)\n",
      "tensor(0.3260, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3053, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0369,  0.2408], grad_fn=<MulBackward0>)\n",
      "tensor(0.5709, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6401, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0014,  0.9629], grad_fn=<MulBackward0>)\n",
      "tensor(0.4964, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5783, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0292, 0.7461], grad_fn=<MulBackward0>)\n",
      "tensor(0.5221, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3517, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0374,  0.7791], grad_fn=<MulBackward0>)\n",
      "tensor(0.4951, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6330, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0157, 0.6585], grad_fn=<MulBackward0>)\n",
      "tensor(0.6698, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4719, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0752,  1.3233], grad_fn=<MulBackward0>)\n",
      "tensor(0.4093, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3172, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0405,  0.5229], grad_fn=<MulBackward0>)\n",
      "tensor(0.3742, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4190, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0065, 0.3581], grad_fn=<MulBackward0>)\n",
      "tensor(0.4091, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5193, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0095,  0.4598], grad_fn=<MulBackward0>)\n",
      "tensor(0.4882, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6317, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0095,  0.6376], grad_fn=<MulBackward0>)\n",
      "tensor(0.4866, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4704, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1287,  0.7165], grad_fn=<MulBackward0>)\n",
      "tensor(0.6396, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4766, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0447,  1.3651], grad_fn=<MulBackward0>)\n",
      "tensor(0.4901, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3781, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0864,  0.7423], grad_fn=<MulBackward0>)\n",
      "tensor(0.6792, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4604, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0558,  1.2944], grad_fn=<MulBackward0>)\n",
      "tensor(0.5451, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5603, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0334, 1.1250], grad_fn=<MulBackward0>)\n",
      "tensor(0.5109, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5074, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0407, 1.3010], grad_fn=<MulBackward0>)\n",
      "tensor(0.7235, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5066, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1126,  1.4326], grad_fn=<MulBackward0>)\n",
      "tensor(0.5698, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7061, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0111,  0.8028], grad_fn=<MulBackward0>)\n",
      "tensor(0.6967, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6485, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0280,  1.2293], grad_fn=<MulBackward0>)\n",
      "tensor(0.2866, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2819, grad_fn=<RsubBackward1>)\n",
      "tensor([-7.5488e-05,  7.9055e-02], grad_fn=<MulBackward0>)\n",
      "tensor(0.4872, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4932, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0448, 0.5495], grad_fn=<MulBackward0>)\n",
      "tensor(0.4642, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4097, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0443,  0.6678], grad_fn=<MulBackward0>)\n",
      "tensor(0.6903, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4858, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1443,  1.3606], grad_fn=<MulBackward0>)\n",
      "tensor(0.5007, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5006, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0557,  0.4963], grad_fn=<MulBackward0>)\n",
      "tensor(0.4937, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3727, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0207,  0.7570], grad_fn=<MulBackward0>)\n",
      "tensor(0.3919, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3459, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0743,  0.4577], grad_fn=<MulBackward0>)\n",
      "tensor(0.3627, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3241, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0054,  0.3573], grad_fn=<MulBackward0>)\n",
      "tensor(0.3733, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4272, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0025, 0.3646], grad_fn=<MulBackward0>)\n",
      "tensor(0.5815, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7121, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0243,  0.8231], grad_fn=<MulBackward0>)\n",
      "tensor(0.3305, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3418, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0026,  0.1971], grad_fn=<MulBackward0>)\n",
      "tensor(0.6081, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4156, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0391,  1.0476], grad_fn=<MulBackward0>)\n",
      "tensor(0.6417, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5084, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1744,  1.5088], grad_fn=<MulBackward0>)\n",
      "tensor(0.5120, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6567, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0097,  0.6983], grad_fn=<MulBackward0>)\n",
      "tensor(0.3980, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4981, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0009, 0.4451], grad_fn=<MulBackward0>)\n",
      "tensor(0.4392, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5377, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0214,  0.5345], grad_fn=<MulBackward0>)\n",
      "tensor(0.5621, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5404, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0351, 1.2786], grad_fn=<MulBackward0>)\n",
      "tensor(0.4427, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4429, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0748,  0.4201], grad_fn=<MulBackward0>)\n",
      "tensor(0.4353, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4149, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0214,  0.4937], grad_fn=<MulBackward0>)\n",
      "tensor(0.3548, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3021, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0134,  0.3798], grad_fn=<MulBackward0>)\n",
      "tensor(0.5166, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5023, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0399,  1.4445], grad_fn=<MulBackward0>)\n",
      "tensor(0.6637, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5866, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0185,  1.3084], grad_fn=<MulBackward0>)\n",
      "tensor(0.4889, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4962, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0232,  0.5826], grad_fn=<MulBackward0>)\n",
      "tensor(0.4575, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5114, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0069,  0.5892], grad_fn=<MulBackward0>)\n",
      "tensor(0.4250, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4714, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0052, 0.4743], grad_fn=<MulBackward0>)\n",
      "tensor(0.6322, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4507, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1409,  1.1983], grad_fn=<MulBackward0>)\n",
      "tensor(0.5841, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5480, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0190, 1.3149], grad_fn=<MulBackward0>)\n",
      "tensor(0.4649, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4072, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0183,  0.6654], grad_fn=<MulBackward0>)\n",
      "tensor(0.6997, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5037, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0835,  1.4519], grad_fn=<MulBackward0>)\n",
      "tensor(0.6403, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4388, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0471,  1.1962], grad_fn=<MulBackward0>)\n",
      "tensor(0.2744, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2738, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0171, 0.0177], grad_fn=<MulBackward0>)\n",
      "tensor(0.2998, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3120, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0119, 0.1268], grad_fn=<MulBackward0>)\n",
      "tensor(0.7209, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5575, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0252,  1.3766], grad_fn=<MulBackward0>)\n",
      "tensor(0.7154, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4939, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0923,  1.3673], grad_fn=<MulBackward0>)\n",
      "tensor(0.7216, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5139, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1329,  1.4450], grad_fn=<MulBackward0>)\n",
      "tensor(0.3809, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3151, grad_fn=<RsubBackward1>)\n",
      "tensor([3.0839e-04, 4.5162e-01], grad_fn=<MulBackward0>)\n",
      "tensor(0.5053, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4039, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0197,  0.8275], grad_fn=<MulBackward0>)\n",
      "tensor(0.4984, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4972, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1250,  0.6996], grad_fn=<MulBackward0>)\n",
      "tensor(0.4452, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3322, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0510,  0.5928], grad_fn=<MulBackward0>)\n",
      "tensor(0.3767, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4263, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0074,  0.3727], grad_fn=<MulBackward0>)\n",
      "tensor(0.5643, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6336, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0371,  0.9572], grad_fn=<MulBackward0>)\n",
      "tensor(0.4565, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4729, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0132, 0.4812], grad_fn=<MulBackward0>)\n",
      "tensor(0.4916, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5923, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0278, 0.7053], grad_fn=<MulBackward0>)\n",
      "tensor(0.5013, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5032, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0247, 0.9889], grad_fn=<MulBackward0>)\n",
      "tensor(0.2829, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2851, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0009, 0.0453], grad_fn=<MulBackward0>)\n",
      "tensor(0.3648, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3353, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0273,  0.3344], grad_fn=<MulBackward0>)\n",
      "tensor(0.2925, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2844, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0217,  0.1159], grad_fn=<MulBackward0>)\n",
      "tensor(0.6884, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4437, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0827,  1.2091], grad_fn=<MulBackward0>)\n",
      "tensor(0.5575, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5851, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0285, 1.0686], grad_fn=<MulBackward0>)\n",
      "tensor(0.5276, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4642, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0369,  1.0625], grad_fn=<MulBackward0>)\n",
      "tensor(0.5353, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5453, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0275,  1.1407], grad_fn=<MulBackward0>)\n",
      "tensor(0.5985, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6652, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0311, 1.0016], grad_fn=<MulBackward0>)\n",
      "tensor(0.4398, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5414, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0302, 0.5382], grad_fn=<MulBackward0>)\n",
      "tensor(0.4876, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5404, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0128, 0.7377], grad_fn=<MulBackward0>)\n",
      "tensor(0.4258, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3771, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0011, 0.5461], grad_fn=<MulBackward0>)\n",
      "tensor(0.4823, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4408, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0322,  0.7422], grad_fn=<MulBackward0>)\n",
      "tensor(0.3979, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4672, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0181, 0.4250], grad_fn=<MulBackward0>)\n",
      "tensor(0.2834, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2806, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0025,  0.0528], grad_fn=<MulBackward0>)\n",
      "tensor(0.3893, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3688, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0339,  0.3806], grad_fn=<MulBackward0>)\n",
      "tensor(0.7159, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6236, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0193,  1.2743], grad_fn=<MulBackward0>)\n",
      "tensor(0.6669, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6081, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0060,  1.2579], grad_fn=<MulBackward0>)\n",
      "tensor(0.3607, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3641, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0111, 0.2535], grad_fn=<MulBackward0>)\n",
      "tensor(0.4047, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4321, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0122,  0.3821], grad_fn=<MulBackward0>)\n",
      "tensor(0.4056, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3316, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0148,  0.5080], grad_fn=<MulBackward0>)\n",
      "tensor(0.6498, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7003, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0249,  1.0647], grad_fn=<MulBackward0>)\n",
      "tensor(0.4918, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5488, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0105, 0.7517], grad_fn=<MulBackward0>)\n",
      "tensor(0.5060, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5093, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0394, 1.1126], grad_fn=<MulBackward0>)\n",
      "tensor(0.5946, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5510, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0208,  1.3204], grad_fn=<MulBackward0>)\n",
      "tensor(0.4053, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4216, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0181, 0.3633], grad_fn=<MulBackward0>)\n",
      "tensor(0.3611, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3024, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0125,  0.3937], grad_fn=<MulBackward0>)\n",
      "tensor(0.3438, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2985, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0272,  0.3295], grad_fn=<MulBackward0>)\n",
      "tensor(0.4711, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4672, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0949,  0.5082], grad_fn=<MulBackward0>)\n",
      "tensor(0.2863, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2882, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0341, 0.0550], grad_fn=<MulBackward0>)\n",
      "tensor(0.4777, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4401, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0371,  0.7189], grad_fn=<MulBackward0>)\n",
      "tensor(0.4961, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6089, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0296, 0.6853], grad_fn=<MulBackward0>)\n",
      "tensor(0.5595, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4180, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1112,  0.9587], grad_fn=<MulBackward0>)\n",
      "tensor(0.6682, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4751, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0692,  1.3563], grad_fn=<MulBackward0>)\n",
      "tensor(0.5228, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4924, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1781,  1.3144], grad_fn=<MulBackward0>)\n",
      "tensor(0.6594, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5847, grad_fn=<RsubBackward1>)\n",
      "tensor([2.3999e-05, 1.3003e+00], grad_fn=<MulBackward0>)\n",
      "tensor(0.6208, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7225, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0048, 0.9326], grad_fn=<MulBackward0>)\n",
      "tensor(0.6509, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4157, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1011,  1.0800], grad_fn=<MulBackward0>)\n",
      "tensor(0.5587, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4155, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0420,  0.9601], grad_fn=<MulBackward0>)\n",
      "tensor(0.7103, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6245, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0159,  1.2731], grad_fn=<MulBackward0>)\n",
      "tensor(0.5306, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6089, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0313, 0.8486], grad_fn=<MulBackward0>)\n",
      "tensor(0.3648, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3826, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0196,  0.2745], grad_fn=<MulBackward0>)\n",
      "tensor(0.5377, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4437, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0328,  1.0032], grad_fn=<MulBackward0>)\n",
      "tensor(0.4530, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4221, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1092,  0.6089], grad_fn=<MulBackward0>)\n",
      "tensor(0.6178, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4439, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0470,  1.2012], grad_fn=<MulBackward0>)\n",
      "tensor(0.4853, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5892, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0018, 0.6708], grad_fn=<MulBackward0>)\n",
      "tensor(0.4914, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3451, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0238,  0.7114], grad_fn=<MulBackward0>)\n",
      "tensor(0.5118, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4049, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1099,  0.8363], grad_fn=<MulBackward0>)\n",
      "tensor(0.3078, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3235, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0026, 0.1474], grad_fn=<MulBackward0>)\n",
      "tensor(0.3240, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3347, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0170, 0.1739], grad_fn=<MulBackward0>)\n",
      "tensor(0.4827, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5364, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0107, 0.7012], grad_fn=<MulBackward0>)\n",
      "tensor(0.2710, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2711, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0210, 0.0003], grad_fn=<MulBackward0>)\n",
      "tensor(0.5857, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5646, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0243,  1.2677], grad_fn=<MulBackward0>)\n",
      "tensor(0.2872, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2807, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0183, 0.0935], grad_fn=<MulBackward0>)\n",
      "tensor(0.4396, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4321, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0745,  0.4593], grad_fn=<MulBackward0>)\n",
      "tensor(0.6596, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7096, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0074,  1.0510], grad_fn=<MulBackward0>)\n",
      "tensor(0.4946, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4902, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0280,  0.6839], grad_fn=<MulBackward0>)\n",
      "tensor(0.5434, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5260, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0156, 1.3061], grad_fn=<MulBackward0>)\n",
      "tensor(0.5344, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6386, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0072,  0.8244], grad_fn=<MulBackward0>)\n",
      "tensor(0.4763, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4799, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0401,  0.4786], grad_fn=<MulBackward0>)\n",
      "tensor(0.5544, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6926, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0170,  0.7888], grad_fn=<MulBackward0>)\n",
      "tensor(0.6282, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4101, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0514,  1.0651], grad_fn=<MulBackward0>)\n",
      "tensor(0.3727, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3544, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0635,  0.3588], grad_fn=<MulBackward0>)\n",
      "tensor(0.4687, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5842, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0151, 0.6272], grad_fn=<MulBackward0>)\n",
      "tensor(0.5647, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4740, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0301,  1.2695], grad_fn=<MulBackward0>)\n",
      "tensor(0.3385, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3232, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0361,  0.2621], grad_fn=<MulBackward0>)\n",
      "tensor(0.3883, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3270, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0526,  0.4604], grad_fn=<MulBackward0>)\n",
      "tensor(0.3581, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3042, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0327,  0.3767], grad_fn=<MulBackward0>)\n",
      "tensor(0.5194, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4419, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1206,  0.9300], grad_fn=<MulBackward0>)\n",
      "tensor(0.4903, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6102, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0254, 0.6671], grad_fn=<MulBackward0>)\n",
      "tensor(0.3429, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3507, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0190, 0.2011], grad_fn=<MulBackward0>)\n",
      "tensor(0.4759, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4771, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0008, 0.4587], grad_fn=<MulBackward0>)\n",
      "tensor(0.5336, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4765, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0372,  1.1575], grad_fn=<MulBackward0>)\n",
      "tensor(0.6376, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6004, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0150, 1.2478], grad_fn=<MulBackward0>)\n",
      "tensor(0.6547, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6811, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0363,  1.1123], grad_fn=<MulBackward0>)\n",
      "tensor(0.7133, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5004, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1332,  1.4324], grad_fn=<MulBackward0>)\n",
      "tensor(0.3102, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2990, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0194,  0.1833], grad_fn=<MulBackward0>)\n",
      "tensor(0.4980, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4740, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0399,  0.8471], grad_fn=<MulBackward0>)\n",
      "tensor(0.6276, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4870, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1596,  1.3756], grad_fn=<MulBackward0>)\n",
      "tensor(0.4497, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4427, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0065,  0.4789], grad_fn=<MulBackward0>)\n",
      "tensor(0.3956, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3202, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0142,  0.4862], grad_fn=<MulBackward0>)\n",
      "tensor(0.5021, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5055, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0177,  0.9836], grad_fn=<MulBackward0>)\n",
      "tensor(0.7109, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5490, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0284,  1.3818], grad_fn=<MulBackward0>)\n",
      "tensor(0.4000, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3329, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0519,  0.4808], grad_fn=<MulBackward0>)\n",
      "tensor(0.6540, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7169, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0119,  1.0306], grad_fn=<MulBackward0>)\n",
      "tensor(0.4439, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5094, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0076, 0.5711], grad_fn=<MulBackward0>)\n",
      "tensor(0.4731, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4829, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0222, 0.4959], grad_fn=<MulBackward0>)\n",
      "tensor(0.3000, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3108, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0053, 0.1117], grad_fn=<MulBackward0>)\n",
      "tensor(0.3618, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3441, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0350,  0.3043], grad_fn=<MulBackward0>)\n",
      "tensor(0.3927, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4648, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0212,  0.4163], grad_fn=<MulBackward0>)\n",
      "tensor(0.7164, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5581, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0335,  1.3688], grad_fn=<MulBackward0>)\n",
      "tensor(0.4097, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3599, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0745,  0.5188], grad_fn=<MulBackward0>)\n",
      "tensor(0.3239, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3564, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0195,  0.2137], grad_fn=<MulBackward0>)\n",
      "tensor(0.3799, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3724, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0173,  0.3159], grad_fn=<MulBackward0>)\n",
      "tensor(0.3194, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3119, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0008,  0.1780], grad_fn=<MulBackward0>)\n",
      "tensor(0.3134, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3374, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0211, 0.1745], grad_fn=<MulBackward0>)\n",
      "tensor(0.6027, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3960, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1101,  0.9671], grad_fn=<MulBackward0>)\n",
      "tensor(0.5814, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7017, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0015, 0.8205], grad_fn=<MulBackward0>)\n",
      "tensor(0.4994, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5211, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0098, 0.8315], grad_fn=<MulBackward0>)\n",
      "tensor(0.5059, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4017, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0953,  0.8124], grad_fn=<MulBackward0>)\n",
      "tensor(0.6767, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4283, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0716,  1.1536], grad_fn=<MulBackward0>)\n",
      "tensor(0.5225, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5236, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0240, 1.1955], grad_fn=<MulBackward0>)\n",
      "tensor(0.4159, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4213, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0522,  0.3585], grad_fn=<MulBackward0>)\n",
      "tensor(0.5807, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6746, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0246,  0.9270], grad_fn=<MulBackward0>)\n",
      "tensor(0.6771, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5844, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0235,  1.3317], grad_fn=<MulBackward0>)\n",
      "tensor(0.6278, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4804, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1615,  1.3520], grad_fn=<MulBackward0>)\n",
      "tensor(0.4507, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4483, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0009, 0.4281], grad_fn=<MulBackward0>)\n",
      "tensor(0.3622, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4045, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0059, 0.3261], grad_fn=<MulBackward0>)\n",
      "tensor(0.5488, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5350, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0329, 1.2806], grad_fn=<MulBackward0>)\n",
      "tensor(0.5210, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5763, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0094,  0.8806], grad_fn=<MulBackward0>)\n",
      "tensor(0.4791, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4853, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0140, 0.4812], grad_fn=<MulBackward0>)\n",
      "tensor(0.4103, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4036, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0865,  0.4041], grad_fn=<MulBackward0>)\n",
      "tensor(0.3800, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3269, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0587,  0.4361], grad_fn=<MulBackward0>)\n",
      "tensor(0.4909, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4894, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0386,  0.5388], grad_fn=<MulBackward0>)\n",
      "tensor(0.5793, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5132, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0367,  1.4344], grad_fn=<MulBackward0>)\n",
      "tensor(0.6647, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4289, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1015,  1.1357], grad_fn=<MulBackward0>)\n",
      "tensor(0.5456, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5541, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0286,  1.1544], grad_fn=<MulBackward0>)\n",
      "tensor(0.5042, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4640, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0401,  0.9039], grad_fn=<MulBackward0>)\n",
      "tensor(0.4023, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5071, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0107,  0.4488], grad_fn=<MulBackward0>)\n",
      "tensor(0.6544, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5040, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0629,  1.4973], grad_fn=<MulBackward0>)\n",
      "tensor(0.2862, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2876, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0115, 0.0505], grad_fn=<MulBackward0>)\n",
      "tensor(0.3005, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3183, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0115, 0.1446], grad_fn=<MulBackward0>)\n",
      "tensor(0.3110, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2917, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0037,  0.1947], grad_fn=<MulBackward0>)\n",
      "tensor(0.4787, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5017, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0100, 0.6258], grad_fn=<MulBackward0>)\n",
      "tensor(0.4202, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4281, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0485,  0.3684], grad_fn=<MulBackward0>)\n",
      "tensor(0.3489, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3612, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0303, 0.2516], grad_fn=<MulBackward0>)\n",
      "tensor(0.5393, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4872, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1642,  1.3000], grad_fn=<MulBackward0>)\n",
      "tensor(0.5859, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4642, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1550,  1.2128], grad_fn=<MulBackward0>)\n",
      "tensor(0.6926, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6680, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0380,  1.1877], grad_fn=<MulBackward0>)\n",
      "tensor(0.6618, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5778, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0158,  1.3224], grad_fn=<MulBackward0>)\n",
      "tensor(0.3445, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3011, grad_fn=<RsubBackward1>)\n",
      "tensor([1.3714e-04, 3.3625e-01], grad_fn=<MulBackward0>)\n",
      "tensor(0.5034, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5087, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0016,  0.9915], grad_fn=<MulBackward0>)\n",
      "tensor(0.6750, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6761, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0262,  1.1619], grad_fn=<MulBackward0>)\n",
      "tensor(0.2912, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2989, grad_fn=<RsubBackward1>)\n",
      "tensor([-4.8173e-05,  9.2187e-02], grad_fn=<MulBackward0>)\n",
      "tensor(0.5046, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5219, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0159, 0.9201], grad_fn=<MulBackward0>)\n",
      "tensor(0.4398, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4112, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1002,  0.5624], grad_fn=<MulBackward0>)\n",
      "tensor(0.4962, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4316, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1142,  0.8224], grad_fn=<MulBackward0>)\n",
      "tensor(0.4767, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4897, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0286,  0.5409], grad_fn=<MulBackward0>)\n",
      "tensor(0.3631, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3149, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0055,  0.3850], grad_fn=<MulBackward0>)\n",
      "tensor(0.4843, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4846, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0667,  0.4937], grad_fn=<MulBackward0>)\n",
      "tensor(0.5047, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4780, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1266,  0.9736], grad_fn=<MulBackward0>)\n",
      "tensor(0.5752, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5317, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0246, 1.3479], grad_fn=<MulBackward0>)\n",
      "tensor(0.5137, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4991, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0506,  1.5192], grad_fn=<MulBackward0>)\n",
      "tensor(0.4974, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4969, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1152,  0.6039], grad_fn=<MulBackward0>)\n",
      "tensor(0.4739, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4957, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0212,  0.5788], grad_fn=<MulBackward0>)\n",
      "tensor(0.3612, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4258, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0221, 0.3354], grad_fn=<MulBackward0>)\n",
      "tensor(0.2754, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2742, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0129, 0.0313], grad_fn=<MulBackward0>)\n",
      "tensor(0.6362, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7203, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0062,  0.9709], grad_fn=<MulBackward0>)\n",
      "tensor(0.7039, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4937, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1437,  1.3841], grad_fn=<MulBackward0>)\n",
      "tensor(0.5353, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4184, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0098,  0.9188], grad_fn=<MulBackward0>)\n",
      "tensor(0.6241, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4542, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0520,  1.2479], grad_fn=<MulBackward0>)\n",
      "tensor(0.3747, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3170, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0494,  0.4248], grad_fn=<MulBackward0>)\n",
      "tensor(0.5787, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5171, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0414,  1.4192], grad_fn=<MulBackward0>)\n",
      "tensor(0.5872, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6004, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0224, 1.1375], grad_fn=<MulBackward0>)\n",
      "tensor(0.6080, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5911, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0278,  1.2373], grad_fn=<MulBackward0>)\n",
      "tensor(0.7147, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6383, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0252,  1.2502], grad_fn=<MulBackward0>)\n",
      "tensor(0.6186, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6269, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0257, 1.1439], grad_fn=<MulBackward0>)\n",
      "tensor(0.5653, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4589, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1360,  1.1425], grad_fn=<MulBackward0>)\n",
      "tensor(0.3628, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3741, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0082,  0.2518], grad_fn=<MulBackward0>)\n",
      "tensor(0.4357, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3547, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0082, 0.6064], grad_fn=<MulBackward0>)\n",
      "tensor(0.5653, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4134, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0252,  1.0014], grad_fn=<MulBackward0>)\n",
      "tensor(0.3377, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3741, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0120, 0.2604], grad_fn=<MulBackward0>)\n",
      "tensor(0.6362, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4041, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0647,  1.0591], grad_fn=<MulBackward0>)\n",
      "tensor(0.5888, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4758, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1500,  1.2896], grad_fn=<MulBackward0>)\n",
      "tensor(0.5867, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7120, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0009, 0.8401], grad_fn=<MulBackward0>)\n",
      "tensor(0.6095, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4749, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1515,  1.3070], grad_fn=<MulBackward0>)\n",
      "tensor(0.4734, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6117, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0040,  0.5984], grad_fn=<MulBackward0>)\n",
      "tensor(0.3007, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2989, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0112,  0.1002], grad_fn=<MulBackward0>)\n",
      "tensor(0.2860, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2840, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0102,  0.0613], grad_fn=<MulBackward0>)\n",
      "tensor(0.5047, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5065, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0238, 1.1402], grad_fn=<MulBackward0>)\n",
      "tensor(0.4477, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4121, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0876,  0.5923], grad_fn=<MulBackward0>)\n",
      "tensor(0.5168, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4889, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0409,  1.1997], grad_fn=<MulBackward0>)\n",
      "tensor(0.6479, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7274, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0197,  0.9886], grad_fn=<MulBackward0>)\n",
      "tensor(0.4516, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4575, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0700,  0.4205], grad_fn=<MulBackward0>)\n",
      "tensor(0.6662, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6847, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0227,  1.1191], grad_fn=<MulBackward0>)\n",
      "tensor(0.6655, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4659, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0516,  1.2853], grad_fn=<MulBackward0>)\n",
      "tensor(0.4789, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4730, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0393,  0.5650], grad_fn=<MulBackward0>)\n",
      "tensor(0.6546, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6566, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0189,  1.1567], grad_fn=<MulBackward0>)\n",
      "tensor(0.5919, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4640, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0303,  1.2694], grad_fn=<MulBackward0>)\n",
      "tensor(0.6029, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4787, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1630,  1.3093], grad_fn=<MulBackward0>)\n",
      "tensor(0.3010, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3052, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0111, 0.0977], grad_fn=<MulBackward0>)\n",
      "tensor(0.5908, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3910, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0934,  0.9476], grad_fn=<MulBackward0>)\n",
      "tensor(0.4877, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5049, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0062, 0.6753], grad_fn=<MulBackward0>)\n",
      "tensor(0.5063, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4993, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0503,  1.4731], grad_fn=<MulBackward0>)\n",
      "tensor(0.4868, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4899, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0016, 0.5023], grad_fn=<MulBackward0>)\n",
      "tensor(0.5277, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5067, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0386, 1.4117], grad_fn=<MulBackward0>)\n",
      "tensor(0.4382, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4872, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0202, 0.5304], grad_fn=<MulBackward0>)\n",
      "tensor(0.4585, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4871, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0126, 0.5392], grad_fn=<MulBackward0>)\n",
      "tensor(0.5256, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3558, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0385,  0.7879], grad_fn=<MulBackward0>)\n",
      "tensor(0.4423, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4093, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0973,  0.5761], grad_fn=<MulBackward0>)\n",
      "tensor(0.6524, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6580, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0279,  1.1478], grad_fn=<MulBackward0>)\n",
      "tensor(0.5405, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5773, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0258,  1.0067], grad_fn=<MulBackward0>)\n",
      "tensor(0.4590, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4723, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0192, 0.4695], grad_fn=<MulBackward0>)\n",
      "tensor(0.5359, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6781, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0127,  0.7572], grad_fn=<MulBackward0>)\n",
      "tensor(0.5963, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7185, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0067,  0.8611], grad_fn=<MulBackward0>)\n",
      "tensor(0.3185, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3517, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0058, 0.2165], grad_fn=<MulBackward0>)\n",
      "tensor(0.5430, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4068, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1078,  0.9110], grad_fn=<MulBackward0>)\n",
      "tensor(0.7040, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4566, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0941,  1.2563], grad_fn=<MulBackward0>)\n",
      "tensor(0.5504, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4876, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0356,  1.3764], grad_fn=<MulBackward0>)\n",
      "tensor(0.6883, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5725, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0233,  1.3458], grad_fn=<MulBackward0>)\n",
      "tensor(0.3113, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3210, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0161, 0.1456], grad_fn=<MulBackward0>)\n",
      "tensor(0.7187, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5053, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1348,  1.4079], grad_fn=<MulBackward0>)\n",
      "tensor(0.7261, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5055, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1106,  1.4241], grad_fn=<MulBackward0>)\n",
      "tensor(0.5667, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6374, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0167,  0.9490], grad_fn=<MulBackward0>)\n",
      "tensor(0.3623, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4352, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0102, 0.3421], grad_fn=<MulBackward0>)\n",
      "tensor(0.5123, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5302, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0266, 0.9958], grad_fn=<MulBackward0>)\n",
      "tensor(0.6736, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6740, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0024,  1.1420], grad_fn=<MulBackward0>)\n",
      "tensor(0.3279, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3230, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0376,  0.1968], grad_fn=<MulBackward0>)\n",
      "tensor(0.5117, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3620, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0679,  0.7810], grad_fn=<MulBackward0>)\n",
      "tensor(0.5039, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5371, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0175, 0.8443], grad_fn=<MulBackward0>)\n",
      "tensor(0.4866, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4876, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0046,  0.4605], grad_fn=<MulBackward0>)\n",
      "tensor(0.3348, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3027, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0034, 0.3014], grad_fn=<MulBackward0>)\n",
      "tensor(0.4207, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3749, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0851,  0.5140], grad_fn=<MulBackward0>)\n",
      "tensor(0.4381, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3288, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0149,  0.6258], grad_fn=<MulBackward0>)\n",
      "tensor(0.3093, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3320, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0235, 0.1689], grad_fn=<MulBackward0>)\n",
      "tensor(0.5621, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5393, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0328,  1.3016], grad_fn=<MulBackward0>)\n",
      "tensor(0.5104, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5116, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0559,  1.1778], grad_fn=<MulBackward0>)\n",
      "tensor(0.5081, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6111, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0290, 0.7619], grad_fn=<MulBackward0>)\n",
      "tensor(0.5391, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3687, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0764,  0.8371], grad_fn=<MulBackward0>)\n",
      "tensor(0.3157, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3455, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0165, 0.2031], grad_fn=<MulBackward0>)\n",
      "tensor(0.4149, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4627, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0007,  0.4505], grad_fn=<MulBackward0>)\n",
      "tensor(0.5049, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5286, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0232, 0.8877], grad_fn=<MulBackward0>)\n",
      "tensor(0.5803, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7120, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0019, 0.8235], grad_fn=<MulBackward0>)\n",
      "tensor(0.4499, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5373, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0215,  0.5643], grad_fn=<MulBackward0>)\n",
      "tensor(0.3507, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4085, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0052,  0.3148], grad_fn=<MulBackward0>)\n",
      "tensor(0.5518, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4946, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1983,  1.4446], grad_fn=<MulBackward0>)\n",
      "tensor(0.4916, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4917, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0798,  0.4936], grad_fn=<MulBackward0>)\n",
      "tensor(0.5348, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6426, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0125, 0.8006], grad_fn=<MulBackward0>)\n",
      "tensor(0.3097, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3298, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0052,  0.1668], grad_fn=<MulBackward0>)\n",
      "tensor(0.4597, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3311, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0328,  0.6312], grad_fn=<MulBackward0>)\n",
      "tensor(0.5377, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5160, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0267, 1.3634], grad_fn=<MulBackward0>)\n",
      "tensor(0.5728, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4396, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0410,  1.0728], grad_fn=<MulBackward0>)\n",
      "tensor(0.4842, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4638, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0273,  0.6984], grad_fn=<MulBackward0>)\n",
      "tensor(0.4039, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3580, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0221,  0.4875], grad_fn=<MulBackward0>)\n",
      "tensor(0.4890, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4770, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1227,  0.7226], grad_fn=<MulBackward0>)\n",
      "tensor(0.4261, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4231, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0538,  0.4031], grad_fn=<MulBackward0>)\n",
      "tensor(0.4634, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3948, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1004,  0.6853], grad_fn=<MulBackward0>)\n",
      "tensor(0.6060, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7231, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0152,  0.8898], grad_fn=<MulBackward0>)\n",
      "tensor(0.3612, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3177, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0096,  0.3804], grad_fn=<MulBackward0>)\n",
      "tensor(0.6716, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4460, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0630,  1.2276], grad_fn=<MulBackward0>)\n",
      "tensor(0.3066, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2935, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0317,  0.1818], grad_fn=<MulBackward0>)\n",
      "tensor(0.5137, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4356, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1134,  0.8998], grad_fn=<MulBackward0>)\n",
      "tensor(0.5051, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3644, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0774,  0.7550], grad_fn=<MulBackward0>)\n",
      "tensor(0.5349, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6730, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0137, 0.7403], grad_fn=<MulBackward0>)\n",
      "tensor(0.5162, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4751, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1398,  1.0415], grad_fn=<MulBackward0>)\n",
      "tensor(0.3529, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3079, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0037,  0.3508], grad_fn=<MulBackward0>)\n",
      "tensor(0.5774, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5425, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0314, 1.3160], grad_fn=<MulBackward0>)\n",
      "tensor(0.4666, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4280, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1182,  0.6841], grad_fn=<MulBackward0>)\n",
      "tensor(0.6675, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4663, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1212,  1.2596], grad_fn=<MulBackward0>)\n",
      "tensor(0.4387, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5285, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0347, 0.5404], grad_fn=<MulBackward0>)\n",
      "tensor(0.7257, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5197, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1286,  1.4700], grad_fn=<MulBackward0>)\n",
      "tensor(0.5687, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4074, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0948,  0.9523], grad_fn=<MulBackward0>)\n",
      "tensor(0.3907, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3528, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0299,  0.4307], grad_fn=<MulBackward0>)\n",
      "tensor(0.5673, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4699, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1644,  1.2029], grad_fn=<MulBackward0>)\n",
      "tensor(0.5529, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4958, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1754,  1.4365], grad_fn=<MulBackward0>)\n",
      "tensor(0.5089, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5309, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0134, 0.9300], grad_fn=<MulBackward0>)\n",
      "tensor(0.5533, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4925, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1734,  1.3938], grad_fn=<MulBackward0>)\n",
      "tensor(0.4467, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5060, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0019,  0.5502], grad_fn=<MulBackward0>)\n",
      "tensor(0.7213, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5211, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1192,  1.4590], grad_fn=<MulBackward0>)\n",
      "tensor(0.5189, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4349, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1113,  0.9175], grad_fn=<MulBackward0>)\n",
      "tensor(0.4249, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5516, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0039,  0.5393], grad_fn=<MulBackward0>)\n",
      "tensor(0.5223, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4777, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0534,  1.1147], grad_fn=<MulBackward0>)\n",
      "tensor(0.2979, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3006, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0124, 0.0838], grad_fn=<MulBackward0>)\n",
      "tensor(0.6392, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6660, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0204,  1.1139], grad_fn=<MulBackward0>)\n",
      "tensor(0.6189, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5247, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0345,  1.4093], grad_fn=<MulBackward0>)\n",
      "tensor(0.5237, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4972, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1793,  1.4442], grad_fn=<MulBackward0>)\n",
      "tensor(0.6596, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4879, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0548,  1.3943], grad_fn=<MulBackward0>)\n",
      "tensor(0.5888, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5369, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0291, 1.3508], grad_fn=<MulBackward0>)\n",
      "tensor(0.7187, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6302, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0157,  1.2648], grad_fn=<MulBackward0>)\n",
      "tensor(0.5364, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6106, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0317, 0.8823], grad_fn=<MulBackward0>)\n",
      "tensor(0.5490, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6001, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0152,  0.9869], grad_fn=<MulBackward0>)\n",
      "tensor(0.3463, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4088, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0153,  0.3183], grad_fn=<MulBackward0>)\n",
      "tensor(0.6988, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4819, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0746,  1.3474], grad_fn=<MulBackward0>)\n",
      "tensor(0.5699, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4989, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0414,  1.5018], grad_fn=<MulBackward0>)\n",
      "tensor(0.5255, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5407, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0253, 1.0778], grad_fn=<MulBackward0>)\n",
      "tensor(0.4530, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4489, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0915,  0.4834], grad_fn=<MulBackward0>)\n",
      "tensor(0.5512, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6804, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0028,  0.7743], grad_fn=<MulBackward0>)\n",
      "tensor(0.5597, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4309, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0273,  1.0221], grad_fn=<MulBackward0>)\n",
      "tensor(0.4599, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5962, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0064,  0.5720], grad_fn=<MulBackward0>)\n",
      "tensor(0.6587, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4992, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1575,  1.4291], grad_fn=<MulBackward0>)\n",
      "tensor(0.3715, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4504, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0025,  0.3725], grad_fn=<MulBackward0>)\n",
      "tensor(0.6525, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5509, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0169, 1.3575], grad_fn=<MulBackward0>)\n",
      "tensor(0.5267, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6157, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0238, 0.8232], grad_fn=<MulBackward0>)\n",
      "tensor(0.4581, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5689, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0184,  0.6015], grad_fn=<MulBackward0>)\n",
      "tensor(0.6284, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7022, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0219,  1.0139], grad_fn=<MulBackward0>)\n",
      "tensor(0.4868, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5003, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0028,  0.6275], grad_fn=<MulBackward0>)\n",
      "tensor(0.4342, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4319, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0845,  0.4179], grad_fn=<MulBackward0>)\n",
      "tensor(0.5619, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4899, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1749,  1.3914], grad_fn=<MulBackward0>)\n",
      "tensor(0.4899, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4832, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1187,  0.6773], grad_fn=<MulBackward0>)\n",
      "tensor(0.4641, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4399, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0268,  0.5943], grad_fn=<MulBackward0>)\n",
      "tensor(0.5295, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4768, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1462,  1.1591], grad_fn=<MulBackward0>)\n",
      "tensor(0.5335, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4147, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1060,  0.9035], grad_fn=<MulBackward0>)\n",
      "tensor(0.5435, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4240, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0382,  0.9845], grad_fn=<MulBackward0>)\n",
      "tensor(0.5716, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6326, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0197, 0.9747], grad_fn=<MulBackward0>)\n",
      "tensor(0.4755, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4154, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1114,  0.7416], grad_fn=<MulBackward0>)\n",
      "tensor(0.3203, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2991, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0285,  0.2321], grad_fn=<MulBackward0>)\n",
      "tensor(0.4396, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5055, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0295, 0.5484], grad_fn=<MulBackward0>)\n",
      "tensor(0.4992, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5269, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0129,  0.8109], grad_fn=<MulBackward0>)\n",
      "tensor(0.6285, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6516, grad_fn=<RsubBackward1>)\n",
      "tensor([4.7359e-04, 1.0995e+00], grad_fn=<MulBackward0>)\n",
      "tensor(0.5402, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5541, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0349, 1.1161], grad_fn=<MulBackward0>)\n",
      "tensor(0.4627, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5167, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0082, 0.6263], grad_fn=<MulBackward0>)\n",
      "tensor(0.4713, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5163, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0066, 0.6290], grad_fn=<MulBackward0>)\n",
      "tensor(0.4913, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4111, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0208,  0.7852], grad_fn=<MulBackward0>)\n",
      "tensor(0.4345, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4824, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0053, 0.5120], grad_fn=<MulBackward0>)\n",
      "tensor(0.5196, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3523, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0404,  0.7763], grad_fn=<MulBackward0>)\n",
      "tensor(0.5145, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6391, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0161, 0.7381], grad_fn=<MulBackward0>)\n",
      "tensor(0.5038, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5185, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0213, 0.9090], grad_fn=<MulBackward0>)\n",
      "tensor(0.7264, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5984, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0139,  1.3250], grad_fn=<MulBackward0>)\n",
      "tensor(0.4829, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5071, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0051,  0.6641], grad_fn=<MulBackward0>)\n",
      "tensor(0.2805, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2788, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0070,  0.0440], grad_fn=<MulBackward0>)\n",
      "tensor(0.4839, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5801, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0315, 0.6784], grad_fn=<MulBackward0>)\n",
      "tensor(0.4363, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4135, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0172,  0.4999], grad_fn=<MulBackward0>)\n",
      "tensor(0.4335, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4141, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0223,  0.4702], grad_fn=<MulBackward0>)\n",
      "tensor(0.4553, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4533, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0154,  0.4455], grad_fn=<MulBackward0>)\n",
      "tensor(0.4776, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4177, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0956,  0.7372], grad_fn=<MulBackward0>)\n",
      "tensor(0.4613, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4809, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0108, 0.5115], grad_fn=<MulBackward0>)\n",
      "tensor(0.5321, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5495, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0230, 1.0837], grad_fn=<MulBackward0>)\n",
      "tensor(0.4347, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5638, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0008, 0.5342], grad_fn=<MulBackward0>)\n",
      "tensor(0.6348, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7120, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0232,  0.9948], grad_fn=<MulBackward0>)\n",
      "tensor(0.6085, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7232, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0070,  0.8991], grad_fn=<MulBackward0>)\n",
      "tensor(0.4302, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5470, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0018,  0.5266], grad_fn=<MulBackward0>)\n",
      "tensor(0.4953, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3395, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0515,  0.7258], grad_fn=<MulBackward0>)\n",
      "tensor(0.3181, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3095, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0105,  0.1711], grad_fn=<MulBackward0>)\n",
      "tensor(0.4962, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4275, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1156,  0.8379], grad_fn=<MulBackward0>)\n",
      "tensor(0.5062, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5357, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0162, 0.8817], grad_fn=<MulBackward0>)\n",
      "tensor(0.5723, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6836, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0209,  0.8844], grad_fn=<MulBackward0>)\n",
      "tensor(0.5103, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4935, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0277,  1.2224], grad_fn=<MulBackward0>)\n",
      "tensor(0.2790, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2792, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0145, 0.0115], grad_fn=<MulBackward0>)\n",
      "tensor(0.7067, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6436, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0323,  1.2501], grad_fn=<MulBackward0>)\n",
      "tensor(0.6024, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6886, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0298,  0.9556], grad_fn=<MulBackward0>)\n",
      "tensor(0.3592, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3559, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0165, 0.2506], grad_fn=<MulBackward0>)\n",
      "tensor(0.4467, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4660, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0230,  0.4656], grad_fn=<MulBackward0>)\n",
      "tensor(0.4629, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5801, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0300, 0.5893], grad_fn=<MulBackward0>)\n",
      "tensor(0.6982, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4478, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1022,  1.2493], grad_fn=<MulBackward0>)\n",
      "tensor(0.6397, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6276, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0178,  1.1948], grad_fn=<MulBackward0>)\n",
      "tensor(0.5484, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6910, grad_fn=<RsubBackward1>)\n",
      "tensor([-4.7068e-04,  7.7662e-01], grad_fn=<MulBackward0>)\n",
      "tensor(0.3444, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4032, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0052, 0.3010], grad_fn=<MulBackward0>)\n",
      "tensor(0.6639, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4550, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0525,  1.2287], grad_fn=<MulBackward0>)\n",
      "tensor(0.6764, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4941, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0666,  1.4263], grad_fn=<MulBackward0>)\n",
      "tensor(0.5627, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3747, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0383,  0.8893], grad_fn=<MulBackward0>)\n",
      "tensor(0.3228, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2954, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0196,  0.2496], grad_fn=<MulBackward0>)\n",
      "tensor(0.4108, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4103, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0023, 0.3423], grad_fn=<MulBackward0>)\n",
      "tensor(0.2971, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3112, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0158, 0.1233], grad_fn=<MulBackward0>)\n",
      "tensor(0.4386, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4059, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0882,  0.5606], grad_fn=<MulBackward0>)\n",
      "tensor(0.5361, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4021, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0203,  0.8841], grad_fn=<MulBackward0>)\n",
      "tensor(0.3632, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4369, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0095, 0.3534], grad_fn=<MulBackward0>)\n",
      "tensor(0.4829, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5418, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0224, 0.7069], grad_fn=<MulBackward0>)\n",
      "tensor(0.7165, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5081, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1372,  1.4283], grad_fn=<MulBackward0>)\n",
      "tensor(0.6402, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6576, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0126, 1.1191], grad_fn=<MulBackward0>)\n",
      "tensor(0.5685, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5397, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0450,  1.3161], grad_fn=<MulBackward0>)\n",
      "tensor(0.3381, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3864, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0210, 0.2694], grad_fn=<MulBackward0>)\n",
      "tensor(0.4737, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5442, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0009, 0.6677], grad_fn=<MulBackward0>)\n",
      "tensor(0.3787, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4012, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0209,  0.3183], grad_fn=<MulBackward0>)\n",
      "tensor(0.6189, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6511, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0161, 1.0815], grad_fn=<MulBackward0>)\n",
      "tensor(0.3237, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3609, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0039,  0.2281], grad_fn=<MulBackward0>)\n",
      "tensor(0.6355, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7086, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0206,  1.0166], grad_fn=<MulBackward0>)\n",
      "tensor(0.5688, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3807, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0401,  0.9063], grad_fn=<MulBackward0>)\n",
      "tensor(0.4993, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4918, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0494,  0.8770], grad_fn=<MulBackward0>)\n",
      "tensor(0.4499, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3640, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0090,  0.6377], grad_fn=<MulBackward0>)\n",
      "tensor(0.3049, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3024, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0046, 0.1137], grad_fn=<MulBackward0>)\n",
      "tensor(0.5635, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5496, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0200, 1.2569], grad_fn=<MulBackward0>)\n",
      "tensor(0.4966, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5195, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0278, 0.8030], grad_fn=<MulBackward0>)\n",
      "tensor(0.4390, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4301, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0098,  0.4462], grad_fn=<MulBackward0>)\n",
      "tensor(0.5004, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3994, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1023,  0.7994], grad_fn=<MulBackward0>)\n",
      "tensor(0.3469, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3681, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0070, 0.2525], grad_fn=<MulBackward0>)\n",
      "tensor(0.4396, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5325, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0234, 0.5651], grad_fn=<MulBackward0>)\n",
      "tensor(0.4691, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4230, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0456,  0.6789], grad_fn=<MulBackward0>)\n",
      "tensor(0.5513, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5814, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0242,  1.0707], grad_fn=<MulBackward0>)\n",
      "tensor(0.5037, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4591, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1256,  0.9056], grad_fn=<MulBackward0>)\n",
      "tensor(0.4445, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3401, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0104,  0.6113], grad_fn=<MulBackward0>)\n",
      "tensor(0.4785, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4874, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0192,  0.5137], grad_fn=<MulBackward0>)\n",
      "tensor(0.4639, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5885, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0098,  0.6103], grad_fn=<MulBackward0>)\n",
      "tensor(0.6931, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4488, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1047,  1.2221], grad_fn=<MulBackward0>)\n",
      "tensor(0.4645, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4641, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0675,  0.4601], grad_fn=<MulBackward0>)\n",
      "tensor(0.3115, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2909, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0109,  0.2002], grad_fn=<MulBackward0>)\n",
      "tensor(0.3591, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4097, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0200, 0.3356], grad_fn=<MulBackward0>)\n",
      "tensor(0.5346, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5188, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0299, 1.3276], grad_fn=<MulBackward0>)\n",
      "tensor(0.4148, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4447, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0149, 0.4134], grad_fn=<MulBackward0>)\n",
      "tensor(0.7204, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4894, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0741,  1.3812], grad_fn=<MulBackward0>)\n",
      "tensor(0.5137, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4552, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1240,  0.9400], grad_fn=<MulBackward0>)\n",
      "tensor(0.6461, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5333, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0195, 1.3841], grad_fn=<MulBackward0>)\n",
      "tensor(0.5235, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6126, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0377, 0.8010], grad_fn=<MulBackward0>)\n",
      "tensor(0.4702, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4571, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0256,  0.5666], grad_fn=<MulBackward0>)\n",
      "tensor(0.3746, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4114, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0005, 0.3437], grad_fn=<MulBackward0>)\n",
      "tensor(0.3545, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3883, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0099, 0.2966], grad_fn=<MulBackward0>)\n",
      "tensor(0.4179, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4812, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0089,  0.4797], grad_fn=<MulBackward0>)\n",
      "tensor(0.6947, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5675, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0425,  1.3597], grad_fn=<MulBackward0>)\n",
      "tensor(0.3913, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4895, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0049, 0.4328], grad_fn=<MulBackward0>)\n",
      "tensor(0.6694, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4622, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1445,  1.2752], grad_fn=<MulBackward0>)\n",
      "tensor(0.6831, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6849, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0398,  1.1482], grad_fn=<MulBackward0>)\n",
      "tensor(0.5122, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3927, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0253,  0.8116], grad_fn=<MulBackward0>)\n",
      "tensor(0.6308, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5247, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0080, 1.4001], grad_fn=<MulBackward0>)\n",
      "tensor(0.6404, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5403, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0202,  1.3902], grad_fn=<MulBackward0>)\n",
      "tensor(0.4578, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3785, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0096,  0.6567], grad_fn=<MulBackward0>)\n",
      "tensor(0.5016, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4975, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1484,  1.0814], grad_fn=<MulBackward0>)\n",
      "tensor(0.4320, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3311, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0588,  0.5797], grad_fn=<MulBackward0>)\n",
      "tensor(0.6166, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6634, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0077, 1.0503], grad_fn=<MulBackward0>)\n",
      "tensor(0.6133, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6395, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0378,  1.1080], grad_fn=<MulBackward0>)\n",
      "tensor(0.5940, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6445, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0239,  1.0377], grad_fn=<MulBackward0>)\n",
      "tensor(0.3255, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3638, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0166, 0.2329], grad_fn=<MulBackward0>)\n",
      "tensor(0.3253, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3488, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0174, 0.2130], grad_fn=<MulBackward0>)\n",
      "tensor(0.5849, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4273, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0405,  1.0874], grad_fn=<MulBackward0>)\n",
      "tensor(0.5853, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7123, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0194,  0.8628], grad_fn=<MulBackward0>)\n",
      "tensor(0.4116, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4077, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0635,  0.3876], grad_fn=<MulBackward0>)\n",
      "tensor(0.5140, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5336, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0188, 0.9936], grad_fn=<MulBackward0>)\n",
      "tensor(0.4211, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3228, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0262,  0.5595], grad_fn=<MulBackward0>)\n",
      "tensor(0.3420, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3516, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0125, 0.2164], grad_fn=<MulBackward0>)\n",
      "tensor(0.6215, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3947, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0662,  0.9878], grad_fn=<MulBackward0>)\n",
      "tensor(0.4015, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3229, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0565,  0.4891], grad_fn=<MulBackward0>)\n",
      "tensor(0.6132, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7244, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0134,  0.8946], grad_fn=<MulBackward0>)\n",
      "tensor(0.5127, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5618, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0176,  0.8604], grad_fn=<MulBackward0>)\n",
      "tensor(0.4351, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3902, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0307,  0.5584], grad_fn=<MulBackward0>)\n",
      "tensor(0.6269, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5872, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0233,  1.2739], grad_fn=<MulBackward0>)\n",
      "tensor(0.4036, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4052, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0226, 0.3343], grad_fn=<MulBackward0>)\n",
      "tensor(0.5481, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5500, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0434, 1.1897], grad_fn=<MulBackward0>)\n",
      "tensor(0.3726, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3154, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0083,  0.4199], grad_fn=<MulBackward0>)\n",
      "tensor(0.5569, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5860, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0450,  1.0780], grad_fn=<MulBackward0>)\n",
      "tensor(0.4734, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4783, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0093, 0.4576], grad_fn=<MulBackward0>)\n",
      "tensor(0.3025, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3233, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0061, 0.1633], grad_fn=<MulBackward0>)\n",
      "tensor(0.3400, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3658, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0118, 0.2429], grad_fn=<MulBackward0>)\n",
      "tensor(0.5922, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5482, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0190, 1.3109], grad_fn=<MulBackward0>)\n",
      "tensor(0.7211, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5130, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1269,  1.4541], grad_fn=<MulBackward0>)\n",
      "tensor(0.5355, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3983, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0984,  0.8682], grad_fn=<MulBackward0>)\n",
      "tensor(0.4339, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4452, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0461,  0.4110], grad_fn=<MulBackward0>)\n",
      "tensor(0.4729, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4602, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1224,  0.6128], grad_fn=<MulBackward0>)\n",
      "tensor(0.5151, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4915, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1618,  1.2304], grad_fn=<MulBackward0>)\n",
      "tensor(0.4049, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3153, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0386,  0.5116], grad_fn=<MulBackward0>)\n",
      "tensor(0.5067, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5394, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0102, 0.8669], grad_fn=<MulBackward0>)\n",
      "tensor(0.3013, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2853, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0018, 0.1715], grad_fn=<MulBackward0>)\n",
      "tensor(0.4986, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4747, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1286,  0.8869], grad_fn=<MulBackward0>)\n",
      "tensor(0.7018, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4615, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1125,  1.2696], grad_fn=<MulBackward0>)\n",
      "tensor(0.4297, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4342, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0175,  0.3693], grad_fn=<MulBackward0>)\n",
      "tensor(0.3692, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4172, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0088,  0.3390], grad_fn=<MulBackward0>)\n",
      "tensor(0.3031, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2895, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0209,  0.1699], grad_fn=<MulBackward0>)\n",
      "tensor(0.6081, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5012, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0680,  1.5101], grad_fn=<MulBackward0>)\n",
      "tensor(0.4453, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5364, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0427, 0.5608], grad_fn=<MulBackward0>)\n",
      "tensor(0.4870, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5157, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0036, 0.7232], grad_fn=<MulBackward0>)\n",
      "tensor(0.4846, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3614, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0765,  0.7299], grad_fn=<MulBackward0>)\n",
      "tensor(0.6152, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4033, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1182,  1.0140], grad_fn=<MulBackward0>)\n",
      "tensor(0.5795, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3786, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0545,  0.8995], grad_fn=<MulBackward0>)\n",
      "tensor(0.3919, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3849, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0599,  0.3618], grad_fn=<MulBackward0>)\n",
      "tensor(0.3708, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3092, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0085,  0.4253], grad_fn=<MulBackward0>)\n",
      "tensor(0.5499, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6728, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0224,  0.8031], grad_fn=<MulBackward0>)\n",
      "tensor(0.5932, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3949, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1014,  0.9776], grad_fn=<MulBackward0>)\n",
      "tensor(0.3103, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3046, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0026,  0.1425], grad_fn=<MulBackward0>)\n",
      "tensor(0.4273, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4542, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0175,  0.4325], grad_fn=<MulBackward0>)\n",
      "tensor(0.4466, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3486, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0856,  0.5925], grad_fn=<MulBackward0>)\n",
      "tensor(0.2756, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2760, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0170, 0.0091], grad_fn=<MulBackward0>)\n",
      "tensor(0.5350, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4688, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0479,  1.1266], grad_fn=<MulBackward0>)\n",
      "tensor(0.5151, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6422, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0166,  0.7409], grad_fn=<MulBackward0>)\n",
      "tensor(0.5509, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4504, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0202,  1.0786], grad_fn=<MulBackward0>)\n",
      "tensor(0.5630, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5547, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0387,  1.2330], grad_fn=<MulBackward0>)\n",
      "tensor(0.4788, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4526, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0626,  0.6844], grad_fn=<MulBackward0>)\n",
      "tensor(0.3841, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3834, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0004,  0.3150], grad_fn=<MulBackward0>)\n",
      "tensor(0.5102, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4796, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1276,  1.0366], grad_fn=<MulBackward0>)\n",
      "tensor(0.3730, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4055, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0028, 0.3321], grad_fn=<MulBackward0>)\n",
      "tensor(0.5049, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6227, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0079,  0.7162], grad_fn=<MulBackward0>)\n",
      "tensor(0.4907, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5536, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0175,  0.7299], grad_fn=<MulBackward0>)\n",
      "tensor(0.4949, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5729, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0155,  0.7257], grad_fn=<MulBackward0>)\n",
      "tensor(0.4521, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5085, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0023, 0.5707], grad_fn=<MulBackward0>)\n",
      "tensor(0.3587, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3095, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0406,  0.3664], grad_fn=<MulBackward0>)\n",
      "tensor(0.5177, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5803, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0138,  0.8472], grad_fn=<MulBackward0>)\n",
      "tensor(0.3590, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4276, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0143, 0.3285], grad_fn=<MulBackward0>)\n",
      "tensor(0.4156, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3795, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0331,  0.4622], grad_fn=<MulBackward0>)\n",
      "tensor(0.6830, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5120, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0863,  1.4853], grad_fn=<MulBackward0>)\n",
      "tensor(0.4872, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5766, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0089,  0.6901], grad_fn=<MulBackward0>)\n",
      "tensor(0.4422, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4266, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0765,  0.5098], grad_fn=<MulBackward0>)\n",
      "tensor(0.5181, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4656, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0563,  1.0001], grad_fn=<MulBackward0>)\n",
      "tensor(0.4827, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3805, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0923,  0.7206], grad_fn=<MulBackward0>)\n",
      "tensor(0.5887, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6164, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0415,  1.1027], grad_fn=<MulBackward0>)\n",
      "tensor(0.4071, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4187, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0234, 0.3494], grad_fn=<MulBackward0>)\n",
      "tensor(0.5875, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5397, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0138,  1.3501], grad_fn=<MulBackward0>)\n",
      "tensor(0.6113, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7253, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0138,  0.8965], grad_fn=<MulBackward0>)\n",
      "tensor(0.2968, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2929, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0086,  0.0947], grad_fn=<MulBackward0>)\n",
      "tensor(0.5307, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4795, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1535,  1.1838], grad_fn=<MulBackward0>)\n",
      "tensor(0.5587, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4528, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0333,  1.1215], grad_fn=<MulBackward0>)\n",
      "tensor(0.4750, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4544, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0056,  0.6550], grad_fn=<MulBackward0>)\n",
      "tensor(0.3829, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3849, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0144,  0.2889], grad_fn=<MulBackward0>)\n",
      "tensor(0.4255, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4449, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0218, 0.4036], grad_fn=<MulBackward0>)\n",
      "tensor(0.4532, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3324, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0474,  0.6087], grad_fn=<MulBackward0>)\n",
      "tensor(0.3974, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4816, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0309, 0.4287], grad_fn=<MulBackward0>)\n",
      "tensor(0.4861, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4955, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0249, 0.5736], grad_fn=<MulBackward0>)\n",
      "tensor(0.3098, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3206, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0010,  0.1481], grad_fn=<MulBackward0>)\n",
      "tensor(0.5792, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6221, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0186,  1.0501], grad_fn=<MulBackward0>)\n",
      "tensor(0.5611, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3836, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0956,  0.8830], grad_fn=<MulBackward0>)\n",
      "tensor(0.6252, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7243, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0106,  0.9312], grad_fn=<MulBackward0>)\n",
      "tensor(0.4469, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4658, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0285, 0.4616], grad_fn=<MulBackward0>)\n",
      "tensor(0.2813, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2812, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0231, 0.0399], grad_fn=<MulBackward0>)\n",
      "tensor(0.6048, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6289, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0176, 1.1071], grad_fn=<MulBackward0>)\n",
      "tensor(0.4746, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5460, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0323, 0.6699], grad_fn=<MulBackward0>)\n",
      "tensor(0.3372, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3371, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0474,  0.2049], grad_fn=<MulBackward0>)\n",
      "tensor(0.6167, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7064, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0019,  0.9446], grad_fn=<MulBackward0>)\n",
      "tensor(0.3418, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3529, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0264,  0.2285], grad_fn=<MulBackward0>)\n",
      "tensor(0.5858, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5315, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0087, 1.3644], grad_fn=<MulBackward0>)\n",
      "tensor(0.3113, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3058, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0091,  0.1502], grad_fn=<MulBackward0>)\n",
      "tensor(0.6961, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4558, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1004,  1.2371], grad_fn=<MulBackward0>)\n",
      "tensor(0.4561, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4390, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0253,  0.5374], grad_fn=<MulBackward0>)\n",
      "tensor(0.4070, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3745, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0875,  0.4719], grad_fn=<MulBackward0>)\n",
      "tensor(0.5915, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6907, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0153, 0.8965], grad_fn=<MulBackward0>)\n",
      "tensor(0.3308, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3586, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0108,  0.2315], grad_fn=<MulBackward0>)\n",
      "tensor(0.3725, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3600, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0019,  0.3182], grad_fn=<MulBackward0>)\n",
      "tensor(0.5643, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6705, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0165, 0.8635], grad_fn=<MulBackward0>)\n",
      "tensor(0.3436, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3532, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0239, 0.2225], grad_fn=<MulBackward0>)\n",
      "tensor(0.6641, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6989, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0330,  1.0992], grad_fn=<MulBackward0>)\n",
      "tensor(0.5386, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6601, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0223, 0.7776], grad_fn=<MulBackward0>)\n",
      "tensor(0.5228, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5366, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0307, 1.0879], grad_fn=<MulBackward0>)\n",
      "tensor(0.5798, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3738, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0681,  0.8907], grad_fn=<MulBackward0>)\n",
      "tensor(0.5035, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5077, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0161, 1.0346], grad_fn=<MulBackward0>)\n",
      "tensor(0.3704, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4411, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0080,  0.3677], grad_fn=<MulBackward0>)\n",
      "tensor(0.4739, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4463, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1034,  0.6927], grad_fn=<MulBackward0>)\n",
      "tensor(0.4236, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3715, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0229,  0.5413], grad_fn=<MulBackward0>)\n",
      "tensor(0.4736, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4982, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0017, 0.5928], grad_fn=<MulBackward0>)\n",
      "tensor(0.4801, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4832, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0544,  0.4719], grad_fn=<MulBackward0>)\n",
      "tensor(0.5305, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3714, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0932,  0.8307], grad_fn=<MulBackward0>)\n",
      "tensor(0.5902, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3956, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0936,  0.9364], grad_fn=<MulBackward0>)\n",
      "tensor(0.6187, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7266, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0140,  0.9142], grad_fn=<MulBackward0>)\n",
      "tensor(0.7156, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4750, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0949,  1.3151], grad_fn=<MulBackward0>)\n",
      "tensor(0.4706, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5706, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0211,  0.6482], grad_fn=<MulBackward0>)\n",
      "tensor(0.4395, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5614, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0069, 0.5350], grad_fn=<MulBackward0>)\n",
      "tensor(0.4360, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4916, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0053, 0.5306], grad_fn=<MulBackward0>)\n",
      "tensor(0.4906, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4922, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0598,  0.4876], grad_fn=<MulBackward0>)\n",
      "tensor(0.4474, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4719, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0125, 0.4818], grad_fn=<MulBackward0>)\n",
      "tensor(0.3632, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4195, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0234, 0.3482], grad_fn=<MulBackward0>)\n",
      "tensor(0.3405, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3861, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0152, 0.2770], grad_fn=<MulBackward0>)\n",
      "tensor(0.6612, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6745, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0271,  1.1340], grad_fn=<MulBackward0>)\n",
      "tensor(0.2989, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2964, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0052,  0.0925], grad_fn=<MulBackward0>)\n",
      "tensor(0.5320, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6473, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0220, 0.7819], grad_fn=<MulBackward0>)\n",
      "tensor(0.5237, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3695, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0262,  0.8067], grad_fn=<MulBackward0>)\n",
      "tensor(0.4458, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5775, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0044, 0.5532], grad_fn=<MulBackward0>)\n",
      "tensor(0.3991, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4219, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0189, 0.3473], grad_fn=<MulBackward0>)\n",
      "tensor(0.4500, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5815, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0032,  0.5704], grad_fn=<MulBackward0>)\n",
      "tensor(0.6685, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7081, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0253,  1.0907], grad_fn=<MulBackward0>)\n",
      "tensor(0.6945, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6647, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0141,  1.1972], grad_fn=<MulBackward0>)\n",
      "tensor(0.5704, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4605, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1482,  1.1722], grad_fn=<MulBackward0>)\n",
      "tensor(0.5407, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6502, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0224, 0.8142], grad_fn=<MulBackward0>)\n",
      "tensor(0.3714, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3876, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0375, 0.2929], grad_fn=<MulBackward0>)\n",
      "tensor(0.4868, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4199, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0394,  0.7696], grad_fn=<MulBackward0>)\n",
      "tensor(0.2942, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2936, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0205, 0.0716], grad_fn=<MulBackward0>)\n",
      "tensor(0.6522, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4439, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1349,  1.1760], grad_fn=<MulBackward0>)\n",
      "tensor(0.6474, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6257, grad_fn=<RsubBackward1>)\n",
      "tensor([-6.6561e-04,  1.1980e+00], grad_fn=<MulBackward0>)\n",
      "tensor(0.4966, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4920, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1347,  0.7531], grad_fn=<MulBackward0>)\n",
      "tensor(0.3858, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4352, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0081, 0.3724], grad_fn=<MulBackward0>)\n",
      "tensor(0.5064, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4603, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0349,  0.8964], grad_fn=<MulBackward0>)\n",
      "tensor(0.6738, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6255, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0257,  1.2458], grad_fn=<MulBackward0>)\n",
      "tensor(0.4689, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4728, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0498,  0.4578], grad_fn=<MulBackward0>)\n",
      "tensor(0.6715, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4993, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0765,  1.4355], grad_fn=<MulBackward0>)\n",
      "tensor(0.4997, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4996, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0235, 0.5139], grad_fn=<MulBackward0>)\n",
      "tensor(0.4324, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4332, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0018, 0.3841], grad_fn=<MulBackward0>)\n",
      "tensor(0.6871, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5598, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0059,  1.3523], grad_fn=<MulBackward0>)\n",
      "tensor(0.4966, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4948, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1216,  0.6928], grad_fn=<MulBackward0>)\n",
      "tensor(0.6740, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6449, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0025,  1.2024], grad_fn=<MulBackward0>)\n",
      "tensor(0.6074, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6876, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0206,  0.9807], grad_fn=<MulBackward0>)\n",
      "tensor(0.4598, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3756, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0829,  0.6498], grad_fn=<MulBackward0>)\n",
      "tensor(0.5170, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5194, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0328, 1.1781], grad_fn=<MulBackward0>)\n",
      "tensor(0.4718, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4957, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0104,  0.5847], grad_fn=<MulBackward0>)\n",
      "tensor(0.2739, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2735, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0154, 0.0153], grad_fn=<MulBackward0>)\n",
      "tensor(0.4790, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4798, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0025,  0.4543], grad_fn=<MulBackward0>)\n",
      "tensor(0.4522, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5604, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0100,  0.5772], grad_fn=<MulBackward0>)\n",
      "tensor(0.4286, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3234, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0544,  0.5567], grad_fn=<MulBackward0>)\n",
      "tensor(0.6717, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6228, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0058,  1.2396], grad_fn=<MulBackward0>)\n",
      "tensor(0.4379, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3312, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0267,  0.5867], grad_fn=<MulBackward0>)\n",
      "tensor(0.6487, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4317, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0572,  1.1572], grad_fn=<MulBackward0>)\n",
      "tensor(0.7057, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4729, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0822,  1.3280], grad_fn=<MulBackward0>)\n",
      "tensor(0.4021, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3851, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0150,  0.4015], grad_fn=<MulBackward0>)\n",
      "tensor(0.4004, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3335, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0087,  0.4893], grad_fn=<MulBackward0>)\n",
      "tensor(0.6230, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4964, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0723,  1.4832], grad_fn=<MulBackward0>)\n",
      "tensor(0.5702, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4562, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1298,  1.1244], grad_fn=<MulBackward0>)\n",
      "tensor(0.3805, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3718, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0022,  0.3261], grad_fn=<MulBackward0>)\n",
      "tensor(0.5123, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5580, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0351, 0.8736], grad_fn=<MulBackward0>)\n",
      "tensor(0.5110, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6167, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0253, 0.7452], grad_fn=<MulBackward0>)\n",
      "tensor(0.4700, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4650, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0243,  0.5332], grad_fn=<MulBackward0>)\n",
      "tensor(0.4804, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3399, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0470,  0.6771], grad_fn=<MulBackward0>)\n",
      "tensor(0.5907, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6894, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0110,  0.9289], grad_fn=<MulBackward0>)\n",
      "tensor(0.5763, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4538, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1348,  1.1277], grad_fn=<MulBackward0>)\n",
      "tensor(0.6655, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4188, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0829,  1.1120], grad_fn=<MulBackward0>)\n",
      "tensor(0.6446, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4830, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0465,  1.4014], grad_fn=<MulBackward0>)\n",
      "tensor(0.6948, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4489, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0908,  1.2210], grad_fn=<MulBackward0>)\n",
      "tensor(0.3067, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2912, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0131,  0.1758], grad_fn=<MulBackward0>)\n",
      "tensor(0.4223, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4103, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0135,  0.4158], grad_fn=<MulBackward0>)\n",
      "tensor(0.5213, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5120, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0414, 1.3356], grad_fn=<MulBackward0>)\n",
      "tensor(0.4155, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5282, grad_fn=<RsubBackward1>)\n",
      "tensor([-2.5248e-04,  4.7361e-01], grad_fn=<MulBackward0>)\n",
      "tensor(0.4991, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4498, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1162,  0.8595], grad_fn=<MulBackward0>)\n",
      "tensor(0.7070, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4593, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0849,  1.2775], grad_fn=<MulBackward0>)\n",
      "tensor(0.6986, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6919, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0012,  1.1590], grad_fn=<MulBackward0>)\n",
      "tensor(0.7147, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5779, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0115,  1.3417], grad_fn=<MulBackward0>)\n",
      "tensor(0.5799, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3780, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0521,  0.8889], grad_fn=<MulBackward0>)\n",
      "tensor(0.3198, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3125, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0272,  0.1894], grad_fn=<MulBackward0>)\n",
      "tensor(0.5607, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4437, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0271,  1.0899], grad_fn=<MulBackward0>)\n",
      "tensor(0.3007, grad_fn=<RsubBackward1>)\n",
      "tensor(0.2857, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0029,  0.1620], grad_fn=<MulBackward0>)\n",
      "tensor(0.4437, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4999, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0034, 0.5548], grad_fn=<MulBackward0>)\n",
      "tensor(0.4912, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4904, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0165,  0.5032], grad_fn=<MulBackward0>)\n",
      "tensor(0.6549, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4843, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1473,  1.3557], grad_fn=<MulBackward0>)\n",
      "tensor(0.4818, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4717, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0451,  0.6100], grad_fn=<MulBackward0>)\n",
      "tensor(0.5084, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4977, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0577,  1.3663], grad_fn=<MulBackward0>)\n",
      "tensor(0.5951, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5827, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0053, 1.2149], grad_fn=<MulBackward0>)\n",
      "tensor(0.4864, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3608, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0189,  0.7216], grad_fn=<MulBackward0>)\n",
      "tensor(0.6924, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5059, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1548,  1.4302], grad_fn=<MulBackward0>)\n",
      "tensor(0.4477, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4502, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0678,  0.4143], grad_fn=<MulBackward0>)\n",
      "tensor(0.4134, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5121, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0076, 0.4640], grad_fn=<MulBackward0>)\n",
      "tensor(0.5139, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4826, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0291,  1.1073], grad_fn=<MulBackward0>)\n",
      "tensor(0.5957, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6743, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0106,  0.9854], grad_fn=<MulBackward0>)\n",
      "tensor(0.4175, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4029, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0763,  0.4433], grad_fn=<MulBackward0>)\n",
      "tensor(0.3851, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3538, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0243,  0.4040], grad_fn=<MulBackward0>)\n",
      "tensor(0.3211, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3394, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0027, 0.1904], grad_fn=<MulBackward0>)\n",
      "tensor(0.3903, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3117, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0126,  0.4637], grad_fn=<MulBackward0>)\n",
      "tensor(0.7263, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5119, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.1152,  1.4555], grad_fn=<MulBackward0>)\n",
      "tensor(0.6409, grad_fn=<RsubBackward1>)\n",
      "tensor(0.7043, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0249,  1.0327], grad_fn=<MulBackward0>)\n",
      "tensor(0.5198, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4913, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0492,  1.2790], grad_fn=<MulBackward0>)\n",
      "tensor(0.6233, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6610, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0235,  1.0836], grad_fn=<MulBackward0>)\n",
      "tensor(0.5035, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5062, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0278,  1.0972], grad_fn=<MulBackward0>)\n",
      "tensor(0.3810, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3844, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0247,  0.3124], grad_fn=<MulBackward0>)\n",
      "tensor(0.5544, grad_fn=<RsubBackward1>)\n",
      "tensor(0.3873, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0847,  0.8739], grad_fn=<MulBackward0>)\n",
      "tensor(0.4670, grad_fn=<RsubBackward1>)\n",
      "tensor(0.5504, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0206, 0.6349], grad_fn=<MulBackward0>)\n",
      "tensor(0.5057, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4894, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0433,  1.0467], grad_fn=<MulBackward0>)\n",
      "tensor(0.3957, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4995, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0019, 0.4519], grad_fn=<MulBackward0>)\n",
      "tensor(0.4124, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4470, grad_fn=<RsubBackward1>)\n",
      "tensor([0.0182, 0.4098], grad_fn=<MulBackward0>)\n",
      "tensor(0.5086, grad_fn=<RsubBackward1>)\n",
      "tensor(0.6472, grad_fn=<RsubBackward1>)\n",
      "tensor([-2.1567e-04,  7.2288e-01], grad_fn=<MulBackward0>)\n",
      "tensor(0.4876, grad_fn=<RsubBackward1>)\n",
      "tensor(0.4885, grad_fn=<RsubBackward1>)\n",
      "tensor([-0.0700,  0.5010], grad_fn=<MulBackward0>)\n"
     ]
    }
   ],
   "source": [
    "\n",
    "policy1=PolicyNet(input_dim=pc_size*2)\n",
    "policy1.load_state_dict(torch.load('checkpoints/model_info_5_moving_landmarks_2.pth'))\n",
    "\n",
    "test_list=[]\n",
    "r_prev_list=[]\n",
    "r_list=[]\n",
    "for i in range(1000):\n",
    "\n",
    "    mu_pitch_pc=torch.Tensor(pc_size).uniform_(-np.pi/2,np.pi/2)[0]\n",
    "    mu_yaw_pc=torch.Tensor(pc_size).uniform_(-np.pi,np.pi)[0]\n",
    "    \n",
    "\n",
    "\n",
    "    pitch_pc_1=torch.Tensor(int(pc_size/2)).normal_(mean=mu_pitch_pc,std=0.1)\n",
    "    yaw_pc_1=torch.Tensor(int(pc_size/2)).normal_(mean=mu_yaw_pc,std=0.1)\n",
    "    \n",
    "    pitch_pc_2=torch.Tensor(int(pc_size/2)).normal_(mean=-mu_pitch_pc,std=0.1)\n",
    "    yaw_pc_2=torch.Tensor(int(pc_size/2)).normal_(mean=-mu_yaw_pc,std=0.1)\n",
    "    \n",
    "    pitch_pc=torch.hstack([pitch_pc_2,pitch_pc_1])\n",
    "    yaw_pc=torch.hstack([yaw_pc_1,yaw_pc_1])\n",
    "    \n",
    "    #pitch_pc=torch.Tensor(pc_size).uniform_(-np.pi/2,np.pi/2)\n",
    "    #yaw_pc=torch.Tensor(pc_size).uniform_(-np.pi/2,np.pi/2)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "    bearing=torch.acos(torch.cos(pitch_pc)*torch.cos(yaw_pc))\n",
    "\n",
    "    net_input=torch.hstack([pitch_pc,yaw_pc])\n",
    "\n",
    "    action=action*0\n",
    "    pitch_pc_next=pitch_pc+action[0]\n",
    "    yaw_pc_next=yaw_pc+action[1]\n",
    "    bearing_next=torch.acos(torch.cos(pitch_pc_next)*torch.cos(yaw_pc_next))\n",
    "\n",
    "\n",
    "    a=1.0\n",
    "    fov=np.pi/2\n",
    "    b=bearing_next\n",
    "    v=1/(1+torch.exp(-a*torch.cos(np.pi*b/2/fov)))\n",
    "    r_prev=(1-torch.mean(v))\n",
    "\n",
    "    print(r_prev)\n",
    "\n",
    "\n",
    "    action=policy1.forward(net_input)\n",
    "\n",
    "\n",
    "    pitch_pc_next=pitch_pc+action[0]*1.57\n",
    "    yaw_pc_next=yaw_pc+action[1]*3.14\n",
    "    bearing_next=torch.acos(torch.cos(pitch_pc_next)*torch.cos(yaw_pc_next))\n",
    "\n",
    "\n",
    "    a=1.0\n",
    "    fov=np.pi/2\n",
    "    b=bearing_next\n",
    "    v=1/(1+torch.exp(-a*torch.cos(np.pi*b/2/fov)))\n",
    "    r=(1-torch.mean(v))\n",
    "\n",
    "\n",
    "\n",
    "    print(r)\n",
    "    print(action*torch.Tensor([1.57,3.14]))\n",
    "    \n",
    "    r_diff=(r_prev-r).detach().numpy()\n",
    "    r_prev_list.append(r_prev.detach().numpy())\n",
    "    r_list.append(r.detach().numpy())\n",
    "    test_list.append(r_diff)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 648,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f2d7cb3bd90>"
      ]
     },
     "execution_count": 648,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(r_prev_list)\n",
    "plt.plot(r_list)\n",
    "plt.legend(['prev','after'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 582,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7fa1c1f4fdf0>"
      ]
     },
     "execution_count": 582,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGdCAYAAADAAnMpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAqYklEQVR4nO3df3hU5Z3//9dMJAlRMoAhP8BIgmvRlBIEmzRWvNYaSdQrlbW7F6UqyFqsFK1LrNW0QkRXg7KlbgtCy1XEa9ktVD/btaxsWjaatS5Ts01I28iPCgahmklESiagSSRzf//gm5EhM0kmmeSeSZ6P65pLc+Y+Z973TMh5zX3OuY/DGGMEAABgidN2AQAAYHQjjAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACw6gLbBfSHz+fT+++/r3HjxsnhcNguBwAA9IMxRm1tbZo8ebKcztDjHzERRt5//31lZmbaLgMAAAzAsWPHdMkll4R8PibCyLhx4ySd7UxycrLlagAAQH94vV5lZmb69+OhxEQY6T40k5ycTBgBACDG9HWKBSewAgAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKyKiUnPAESnLp9RTeMJtbS1K3VcovKyJyrOGXpyoy6f0Z5Dx/X/6v6sjzrP6PNZF2vxNVmKvyDy34u6a/N423XiVIcmXhivdNfYPmsEMPwcxhgTzgqvv/661q5dq9raWjU1NekXv/iF5s+f3+s61dXVKi0t1VtvvaXMzEw9+uijuuuuu/r9ml6vVy6XS62trczAihEj3B35QNc9v+2cqRNU++5f1NLWrpSLEiQjHT/dEXYNlQ1NWr1zn5pa2/3LMlyJKi/JUfGMjKDtS3/+e33U2RWw3OGQ7pmbrbKbc/r1ugOtLViNfb2PoZ4fyGc3mM8biFX93X+HPTJy+vRp5ebm6u///u9122239dm+sbFRt9xyi+69917967/+q6qqqvT1r39dGRkZKioqCvflgREh3B35QNcN1tbpkHwhvoKEU8OybXU6fzOe1nYt21anjXfMDthGZUOT7t1WF3Rbxkg/fr1RkiISSELV1q3p/6/xnuuy9cvfN4V8H0O9z1/Ozeh1vVA1DfTzBkaDsEdGAlZ2OPocGXn44Yf1yiuvqKGhwb/sq1/9qk6ePKnKysp+vQ4jIxhJQu0su78jn78jH+i6fe2Ug+lPDV0+o2uffjXoqEP3NtJdiXrj4S/5RxGuqahSc1tHr6/tdEgHnrhpUIds+qqtL939v+e6bP3k9cZ+v3e9vW+D+byDYYQFsaS/++8hP4HV7XarsLAwYFlRUZHcbnfIdTo6OuT1egMeQDTq8hm5D3+ol+vfk/vwh+oKNeRwTvvVO/cF3cl1L1u9c1/Q7YSzbm9te9NXDZJU03ii15290dnRh5rGE/72fQUR6exozb+4j4RZcXi19aW7x5t/0/8gcu56579vg/m8g6lsaNK1T7+qhZt/qwe212vh5t/q2qdfVWVDUxjVAtFnyMOIx+NRWlpawLK0tDR5vV59/PHHQdepqKiQy+XyPzIzM4e6TCBsA9kxhLsjH+i6g9kp91aDJLW09W+73e36216S3j3xUb/b9vaag2EU+jBWX+ud/74N5vM+X/cIy/nb6z40RiBBLIvKS3vLysrU2trqfxw7dsx2SUCAge4Ywt2RD3TdSOyUQ20jdVxiv9bvbtff9pI0dWJSv9v29po2nfu+DebzPlekR1iAaDPkYSQ9PV3Nzc0By5qbm5WcnKyxY8cGXSchIUHJyckBDyBaDGbHEO6OfKDrRmKnHGobedkTleFKVKizFBw6e3JmXvZEf/u0cQl9vp7TId1ZkDWwYvtZ23A4930bzOd9rkiOsADRaMjDSEFBgaqqqgKW7d69WwUFBUP90sCQGMyOIdwd+UDXHcxOubcaJCnO6VB5SY6/7fnrSlJ5SY7/pMo4p0Orb/1sn6+7dG72oOcbObe2gXLobDAayHrnv2+D+bzPFakRFiBahf0v/9SpU6qvr1d9fb2ks5fu1tfX6+jRo5LOHmJZtGiRv/29996rd955R9/5znd04MABPffcc/r5z3+uFStWRKYHwDAbzI4h3B35QNftrW1v+qqhW/GMDG28Y7bSXYHf6NNdiUGvDimekaFNd8xWUnxcz9d0SN+4LnLzjHTXluEKPtqQ4UrUN67LlkOh38elc4M/H0qo920wn/e5IjXCAkSrsC/tra6u1vXXX99j+eLFi7V161bdddddOnLkiKqrqwPWWbFihfbt26dLLrlEK1euZNIzxCz34Q+1cPNv+2z3s6VfUMFlFwd9LtbnGekWyzOw9vU+RtM8I92XLHta24MeHjz/cupz+88lwLCpv/vvQc0zMlwII4gmA9kxhNpOLM/AOhLE0gys3SdNSwr4vQs1xwyTrCEaEEaAQept5xHOjgGIlP6EjEhPsgYMBmEEGIT+/tHn2yeGW28hOdzZcYGhRhgBBiicb5Ycl0c0icT5TEAkDdmN8oCRrK85RBw6O4fIjTnp/qtW+KOOaMElwIhVUTkDK2ALk0shlnEJMGIVYQQ4B98sEcsiNckaMNwII8A5+GaJWBapSdaA4UYYAc7BN0vEunBnxwWiASewAufo/ma5bFudHAo+hwjfLBHtimdk6Mac9IhN2AYMNS7tBYJgDhGMRPxeY7gxzwgwSHyDxEjCzKywgXlGgEFiDhGMFOHOnwMMN05gBYARjvlzEO0IIwAwwjF/DqIdYQQARjjmz0G0I4wAwAjH/DmIdoQRABjhmJkV0Y4wAgCjADOzIppxaS8AjBK9zcwK2EQYAYBRhPlzEI04TAMAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsYgZWABjlunyGKeJhFWEEAEaxyoYmrd65T02t7f5lGa5ElZfkcPM8DBsO0wDAKFXZ0KRl2+oCgogkeVrbtWxbnSobmixVhtGGMAIAo1CXz2j1zn0yQZ7rXrZ65z51+YK1ACKLMAIAo1BN44keIyLnMpKaWttV03hi+IrCqEUYAYBRqKUtdBAZSDtgMAgjADAKpY5LjGg7YDAIIwAwCuVlT1SGK1GhLuB16OxVNXnZE4ezLIxShBEAGIXinA6Vl+RIUo9A0v1zeUkO841gWBBGAGCUKp6RoY13zFa6K/BQTLorURvvmM08Ixg2THoGAKNY8YwM3ZiTzgyssIowAgCjXJzToYLLLrZdBkYxDtMAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALBqQGFkw4YNysrKUmJiovLz81VTU9Nr+2effVbTp0/X2LFjlZmZqRUrVqi9vX1ABQMAgJEl7DCyY8cOlZaWqry8XHV1dcrNzVVRUZFaWlqCtv+3f/s3PfLIIyovL9f+/fv105/+VDt27NB3v/vdQRcPAABiX9hhZN26dVq6dKmWLFminJwcbdq0SUlJSdqyZUvQ9nv27NEXv/hFfe1rX1NWVpbmzZunhQsX9jmaAgAARoewwkhnZ6dqa2tVWFj46QacThUWFsrtdgdd55prrlFtba0/fLzzzjvatWuXbr755kGUDQAARooLwml8/PhxdXV1KS0tLWB5WlqaDhw4EHSdr33tazp+/LiuvfZaGWN05swZ3Xvvvb0epuno6FBHR4f/Z6/XG06ZAAAghgz51TTV1dV66qmn9Nxzz6murk7//u//rldeeUVPPPFEyHUqKirkcrn8j8zMzKEuEwAAWOIwxpj+Nu7s7FRSUpJeeuklzZ8/37988eLFOnnypF5++eUe68ydO1df+MIXtHbtWv+ybdu26Z577tGpU6fkdPbMQ8FGRjIzM9Xa2qrk5OT+lgsAACzyer1yuVx97r/DGhmJj4/XnDlzVFVV5V/m8/lUVVWlgoKCoOt89NFHPQJHXFycJClUDkpISFBycnLAAwAAjExhnTMiSaWlpVq8eLGuvvpq5eXl6dlnn9Xp06e1ZMkSSdKiRYs0ZcoUVVRUSJJKSkq0bt06XXXVVcrPz9ehQ4e0cuVKlZSU+EMJAAAYvcIOIwsWLNAHH3ygVatWyePxaNasWaqsrPSf1Hr06NGAkZBHH31UDodDjz76qN577z1NmjRJJSUlevLJJyPXCwAAELPCOmfElv4ecwIAANFjSM4ZAQAAiDTCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMCqAYWRDRs2KCsrS4mJicrPz1dNTU2v7U+ePKnly5crIyNDCQkJ+sxnPqNdu3YNqGAAADCyXBDuCjt27FBpaak2bdqk/Px8PfvssyoqKtLBgweVmprao31nZ6duvPFGpaam6qWXXtKUKVP07rvvavz48ZGoHwAAxDiHMcaEs0J+fr4+//nPa/369ZIkn8+nzMxM3X///XrkkUd6tN+0aZPWrl2rAwcOaMyYMQMq0uv1yuVyqbW1VcnJyQPaBgAAGF793X+HdZims7NTtbW1Kiws/HQDTqcKCwvldruDrvPLX/5SBQUFWr58udLS0jRjxgw99dRT6urqCvk6HR0d8nq9AQ8AADAyhRVGjh8/rq6uLqWlpQUsT0tLk8fjCbrOO++8o5deekldXV3atWuXVq5cqe9///v6x3/8x5CvU1FRIZfL5X9kZmaGUyYAAIghQ341jc/nU2pqqn7yk59ozpw5WrBggb73ve9p06ZNIdcpKytTa2ur/3Hs2LGhLhMAAFgS1gmsKSkpiouLU3Nzc8Dy5uZmpaenB10nIyNDY8aMUVxcnH/ZlVdeKY/Ho87OTsXHx/dYJyEhQQkJCeGUBgAAYlRYIyPx8fGaM2eOqqqq/Mt8Pp+qqqpUUFAQdJ0vfvGLOnTokHw+n3/Zn/70J2VkZAQNIgAAYHQJ+zBNaWmpNm/erBdeeEH79+/XsmXLdPr0aS1ZskSStGjRIpWVlfnbL1u2TCdOnNADDzygP/3pT3rllVf01FNPafny5ZHrBQAAiFlhzzOyYMECffDBB1q1apU8Ho9mzZqlyspK/0mtR48eldP5acbJzMzUr371K61YsUIzZ87UlClT9MADD+jhhx+OXC8AAEDMCnueERuYZwQAgNgzJPOMAAAARBphBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVAwojGzZsUFZWlhITE5Wfn6+ampp+rbd9+3Y5HA7Nnz9/IC8LAABGoLDDyI4dO1RaWqry8nLV1dUpNzdXRUVFamlp6XW9I0eO6Nvf/rbmzp074GIBAMDIE3YYWbdunZYuXaolS5YoJydHmzZtUlJSkrZs2RJyna6uLt1+++1avXq1pk2bNqiCAQDAyBJWGOns7FRtba0KCws/3YDTqcLCQrnd7pDrPf7440pNTdXdd9/dr9fp6OiQ1+sNeAAAgJEprDBy/PhxdXV1KS0tLWB5WlqaPB5P0HXeeOMN/fSnP9XmzZv7/ToVFRVyuVz+R2ZmZjhlAgCAGDKkV9O0tbXpzjvv1ObNm5WSktLv9crKytTa2up/HDt2bAirBAAANl0QTuOUlBTFxcWpubk5YHlzc7PS09N7tD98+LCOHDmikpIS/zKfz3f2hS+4QAcPHtRll13WY72EhAQlJCSEUxoAAIhRYY2MxMfHa86cOaqqqvIv8/l8qqqqUkFBQY/2V1xxhf74xz+qvr7e//jyl7+s66+/XvX19Rx+AQAA4Y2MSFJpaakWL16sq6++Wnl5eXr22Wd1+vRpLVmyRJK0aNEiTZkyRRUVFUpMTNSMGTMC1h8/frwk9VgOAABGp7DDyIIFC/TBBx9o1apV8ng8mjVrliorK/0ntR49elROJxO7AgCA/nEYY4ztIvri9XrlcrnU2tqq5ORk2+UAAIB+6O/+myEMAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGBV2Jf2AgAQSpfPqKbxhFra2pU6LlF52RMV53TYLgtRjjACAIiIyoYmrd65T02t7f5lGa5ElZfkqHhGhsXKEO04TAMAGLTKhiYt21YXEEQkydParmXb6lTZ0GSpMsQCwggAYFC6fEard+5TsBk0u5et3rlPXb6on2MTlhBGAACDUtN4oseIyLmMpKbWdtU0nhi+ohBTCCMAgEFpaQsdRAbSDqMPYQQAMCip4xIj2g6jD2EEADAoedkTleHqO2j85XTHMFSDWEQYAQAMSpzToZW35PTZ7olX9nMSK4IijAAABm3ChfF9tuEkVoRCGAEADBonsWIwCCMAgEHjJFYMBmEEADBo3SexhroLjUNnp4bPy544nGUhRhBGAACDFud0qLzk7Ems5weS7p/LS3K4aR6CIowAACKieEaGNt4xW+nnXeab7krUxjtmc7M8hMRdewEAEVM8I0M35qSrpvGEWtralTru7KEZRkTQG8IIACCi4pwOFVx2se0yEEM4TAMAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrBhRGNmzYoKysLCUmJio/P181NTUh227evFlz587VhAkTNGHCBBUWFvbaHgAAjC5hh5EdO3aotLRU5eXlqqurU25uroqKitTS0hK0fXV1tRYuXKjXXntNbrdbmZmZmjdvnt57771BFw8AAGKfwxhjwlkhPz9fn//857V+/XpJks/nU2Zmpu6//3498sgjfa7f1dWlCRMmaP369Vq0aFG/XtPr9crlcqm1tVXJycnhlAsAACzp7/47rJGRzs5O1dbWqrCw8NMNOJ0qLCyU2+3u1zY++ugjffLJJ5o4cWLINh0dHfJ6vQEPAAAwMoUVRo4fP66uri6lpaUFLE9LS5PH4+nXNh5++GFNnjw5INCcr6KiQi6Xy//IzMwMp0zEsC6fkfvwh3q5/j25D3+oLl9YA3cAgBh0wXC+2Jo1a7R9+3ZVV1crMTExZLuysjKVlpb6f/Z6vQSSUaCyoUmrd+5TU2u7f1mGK1HlJTkqnpFhsTIAwFAKa2QkJSVFcXFxam5uDlje3Nys9PT0Xtf9p3/6J61Zs0a//vWvNXPmzF7bJiQkKDk5OeCBka2yoUnLttUFBBFJ8rS2a9m2OlU2NFmqDAAw1MIKI/Hx8ZozZ46qqqr8y3w+n6qqqlRQUBByvWeeeUZPPPGEKisrdfXVVw+8WoxIXT6j1Tv3KdgBme5lq3fu45ANAIxQYV/aW1paqs2bN+uFF17Q/v37tWzZMp0+fVpLliyRJC1atEhlZWX+9k8//bRWrlypLVu2KCsrSx6PRx6PR6dOnYpcLxDTahpP9BgROZeR1NTarprGE8NXFABg2IR9zsiCBQv0wQcfaNWqVfJ4PJo1a5YqKyv9J7UePXpUTuenGWfjxo3q7OzU3/7t3wZsp7y8XI899tjgqseI0NIWOogMpB0AILYM6ATW++67T/fdd1/Q56qrqwN+PnLkyEBeAqNI6rjQJzMPpB0AILZwbxpYl5c9URmuRDlCPO/Q2atq8rJDz00DAIhdhBFYF+d0qLwkR5J6BJLun8tLchTnDBVXAACxjDCCqFA8I0Mb75itdFfgoZh0V6I23jGbeUYAYAQb1knPgN4Uz8jQjTnpqmk8oZa2dqWOO3tohhERABjZCCOIKnFOhwouu9h2GQCAYcRhGgAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFZdYLsAAAC6fEY1jSfU0tau1HGJysueqDinw3ZZGCaEEQCAVZUNTVq9c5+aWtv9yzJciSovyVHxjAyLlWG4cJgGAGBNZUOTlm2rCwgikuRpbdeybXWqbGiyVBmGE2EEAGBFl89o9c59MkGe6162euc+dfmCtcBIQhgBAFhR03iix4jIuYykptZ21TSeGL6iYAVhBABgRUtb6CAykHaIXYQRAIAVqeMSI9oOsYswAgCwIi97ojJciQp1Aa9DZ6+qycueOJxlwQLCCADAijinQ+UlOZLUI5B0/1xeksN8I6MAYQQAYE3xjAxtvGO20l2Bh2LSXYnaeMds5hkZJZj0DABgVfGMDN2Yk+6fgTXlogTJSMdPd8h9+ENmYx0FCCMAAOvinA4VXHaxKhua9O0Xf89srKMMh2kAAFGB2VhHL8IIAMA6ZmMd3QgjAADrmI11dCOMAACsYzbW0Y0wAgCwjtlYRzfCCADAOmZjHd0IIwAA65iNdXQjjAAAogKzsY5eTHoGAIga58/GmjoukRlYRwHCCAAgqnTPxorRg8M0AADAKsIIAACwisM0AICY1+UznGcSwwgjAICYVtnQpNU793Gn3xjGYRoAQMziTr8jw6gdGWFIDwBiW193+nXo7J1+b8xJH5K/751nfPoX9xG9e+IjTZ2YpDsLshR/Qejv+NG434mWmgYURjZs2KC1a9fK4/EoNzdXP/rRj5SXlxey/YsvvqiVK1fqyJEjuvzyy/X000/r5ptvHnDRg8WQHgDEvnDu9BvpS4Urdu3T5t80yndOEnpy134tnZutsptzerSPxv1ONNUU9mGaHTt2qLS0VOXl5aqrq1Nubq6KiorU0tIStP2ePXu0cOFC3X333dq7d6/mz5+v+fPnq6GhYdDFDwRDegAwMti602/Frn368euBQUSSfEb68euNqti1L2B5NO53oq2msMPIunXrtHTpUi1ZskQ5OTnatGmTkpKStGXLlqDt//mf/1nFxcV66KGHdOWVV+qJJ57Q7NmztX79+kEXH66+hvSks0N6Xef/hgEAoo6NO/12nvFp828ae22z+TeN6jzjkxSd+51orCmsMNLZ2ana2loVFhZ+ugGnU4WFhXK73UHXcbvdAe0lqaioKGR7Sero6JDX6w14REI4Q3oAgOhm406//+I+0mNE5Hw+c7adFJ37nWisKawwcvz4cXV1dSktLS1geVpamjweT9B1PB5PWO0lqaKiQi6Xy//IzMwMp8yQbA3pAQAiz8adft898VFY7aJxvxONNUXlpb1lZWVqbW31P44dOxaR7doY0gMADJ3hvtPv1IlJYbWLxv1ONNYU1tU0KSkpiouLU3Nzc8Dy5uZmpaenB10nPT09rPaSlJCQoISEhHBK65fuIT1Pa3vQY2UOnf0FjuSQHgBgaA3nnX7vLMjSk7v293qoxuk4206Kzv1ONNYU1shIfHy85syZo6qqKv8yn8+nqqoqFRQUBF2noKAgoL0k7d69O2T7oWRjSA8AMPS67/R766wpKrjs4iH7Ox5/gVNL52b32mbp3Gz/fCPRuN+JxprCPkxTWlqqzZs364UXXtD+/fu1bNkynT59WkuWLJEkLVq0SGVlZf72DzzwgCorK/X9739fBw4c0GOPPabf/e53uu+++yLXizAM95AeAGBkKbs5R9+4Llvn76udDukb1/WcZyQa9zvRVpPDGBP2tTvr16/3T3o2a9Ys/fCHP1R+fr4k6a//+q+VlZWlrVu3+tu/+OKLevTRR/2Tnj3zzDNhTXrm9XrlcrnU2tqq5OTkcMsNKlpmnQMAxCZmYO1bf/ffAwojw20owggAABha/d1/R+XVNAAAYPQgjAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsCuuuvbZ0TxLr9XotVwIAAPqre7/d12TvMRFG2traJEmZmZmWKwEAAOFqa2uTy+UK+XxM3JvG5/Pp/fff17hx4+RwjOyb2Xm9XmVmZurYsWOj7j489J2+0/fRg76Pjr4bY9TW1qbJkyfL6Qx9ZkhMjIw4nU5dcskltssYVsnJySP+lzQU+k7fRxv6Tt9Hst5GRLpxAisAALCKMAIAAKwijESZhIQElZeXKyEhwXYpw46+0/fRhr7Td5wVEyewAgCAkYuREQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRS5588kldc801SkpK0vjx44O2cTgcPR7bt28PaFNdXa3Zs2crISFBf/VXf6WtW7cOffGD1J++Hz16VLfccouSkpKUmpqqhx56SGfOnAloE4t9P19WVlaPz3jNmjUBbf7whz9o7ty5SkxMVGZmpp555hlL1Ubehg0blJWVpcTEROXn56umpsZ2SRH32GOP9fiMr7jiCv/z7e3tWr58uS6++GJddNFF+spXvqLm5maLFQ/c66+/rpKSEk2ePFkOh0P/8R//EfC8MUarVq1SRkaGxo4dq8LCQr399tsBbU6cOKHbb79dycnJGj9+vO6++26dOnVqGHsxMH31/a677urxe1BcXBzQJlb7HgmEEUs6Ozv1d3/3d1q2bFmv7Z5//nk1NTX5H/Pnz/c/19jYqFtuuUXXX3+96uvr9Q//8A/6+te/rl/96ldDXP3g9NX3rq4u3XLLLers7NSePXv0wgsvaOvWrVq1apW/Taz2PZjHH3884DO+//77/c95vV7NmzdPU6dOVW1trdauXavHHntMP/nJTyxWHBk7duxQaWmpysvLVVdXp9zcXBUVFamlpcV2aRH32c9+NuAzfuONN/zPrVixQjt37tSLL76o//mf/9H777+v2267zWK1A3f69Gnl5uZqw4YNQZ9/5pln9MMf/lCbNm3Sm2++qQsvvFBFRUVqb2/3t7n99tv11ltvaffu3frP//xPvf7667rnnnuGqwsD1lffJam4uDjg9+BnP/tZwPOx2veIMLDq+eefNy6XK+hzkswvfvGLkOt+5zvfMZ/97GcDli1YsMAUFRVFsMKhE6rvu3btMk6n03g8Hv+yjRs3muTkZNPR0WGMif2+d5s6dar5wQ9+EPL55557zkyYMMHfb2OMefjhh8306dOHobqhlZeXZ5YvX+7/uaury0yePNlUVFRYrCryysvLTW5ubtDnTp48acaMGWNefPFF/7L9+/cbScbtdg9ThUPj/L9fPp/PpKenm7Vr1/qXnTx50iQkJJif/exnxhhj9u3bZySZ//u///O3+a//+i/jcDjMe++9N2y1D1awv92LFy82t956a8h1RkrfB4qRkSi3fPlypaSkKC8vT1u2bAm4DbPb7VZhYWFA+6KiIrnd7uEuM6Lcbrc+97nPKS0tzb+sqKhIXq9Xb731lr/NSOn7mjVrdPHFF+uqq67S2rVrAw5Hud1uXXfddYqPj/cvKyoq0sGDB/WXv/zFRrkR0dnZqdra2oDP0Ol0qrCwMCY/w768/fbbmjx5sqZNm6bbb79dR48elSTV1tbqk08+CXgfrrjiCl166aUj7n1obGyUx+MJ6KvL5VJ+fr6/r263W+PHj9fVV1/tb1NYWCin06k333xz2GuOtOrqaqWmpmr69OlatmyZPvzwQ/9zI73vfYmJG+WNVo8//ri+9KUvKSkpSb/+9a/1zW9+U6dOndK3vvUtSZLH4wnYYUtSWlqavF6vPv74Y40dO9ZG2YMWql/dz/XWJtb6/q1vfUuzZ8/WxIkTtWfPHpWVlampqUnr1q2TdLaf2dnZAeuc+15MmDBh2GuOhOPHj6urqyvoZ3jgwAFLVQ2N/Px8bd26VdOnT1dTU5NWr16tuXPnqqGhQR6PR/Hx8T3OnUpLS/P/ro8U3f0J9pmf++86NTU14PkLLrhAEydOjPn3o7i4WLfddpuys7N1+PBhffe739VNN90kt9utuLi4Ed33/iCMRNAjjzyip59+utc2+/fvDzh5rTcrV670//9VV12l06dPa+3atf4wEk0i3fdYFs57UVpa6l82c+ZMxcfH6xvf+IYqKiqYKnqEuOmmm/z/P3PmTOXn52vq1Kn6+c9/HjOhGYP31a9+1f//n/vc5zRz5kxddtllqq6u1g033GCxsuhAGImgBx98UHfddVevbaZNmzbg7efn5+uJJ55QR0eHEhISlJ6e3uOs++bmZiUnJw/7H7lI9j09Pb3HVRXd/UxPT/f/N1r6fr7BvBf5+fk6c+aMjhw5ounTp4fsp/TpexGLUlJSFBcXF7Rvsdyv/hg/frw+85nP6NChQ7rxxhvV2dmpkydPBoyOjMT3obs/zc3NysjI8C9vbm7WrFmz/G3OP4H5zJkzOnHixIh7P6ZNm6aUlBQdOnRIN9xww6jqezCEkQiaNGmSJk2aNGTbr6+v14QJE/zfmAsKCrRr166ANrt371ZBQcGQ1RBKJPteUFCgJ598Ui0tLf5hy927dys5OVk5OTn+NtHS9/MN5r2or6+X0+n097ugoEDf+9739Mknn2jMmDGSzvZz+vTpMXuIRpLi4+M1Z84cVVVV+a8Q8/l8qqqq0n333We3uCF26tQpHT58WHfeeafmzJmjMWPGqKqqSl/5ylckSQcPHtTRo0ej4nc5krKzs5Wenq6qqip/+PB6vXrzzTf9V9YVFBTo5MmTqq2t1Zw5cyRJr776qnw+n/Lz822VPiT+/Oc/68MPP/QHs9HU96Bsn0E7Wr377rtm7969ZvXq1eaiiy4ye/fuNXv37jVtbW3GGGN++ctfms2bN5s//vGP5u233zbPPfecSUpKMqtWrfJv45133jFJSUnmoYceMvv37zcbNmwwcXFxprKy0la3+qWvvp85c8bMmDHDzJs3z9TX15vKykozadIkU1ZW5t9GrPb9XHv27DE/+MEPTH19vTl8+LDZtm2bmTRpklm0aJG/zcmTJ01aWpq58847TUNDg9m+fbtJSkoyP/7xjy1WHhnbt283CQkJZuvWrWbfvn3mnnvuMePHjw+4imokePDBB011dbVpbGw0//u//2sKCwtNSkqKaWlpMcYYc++995pLL73UvPrqq+Z3v/udKSgoMAUFBZarHpi2tjb/v2dJZt26dWbv3r3m3XffNcYYs2bNGjN+/Hjz8ssvmz/84Q/m1ltvNdnZ2ebjjz/2b6O4uNhcddVV5s033zRvvPGGufzyy83ChQttdanfeut7W1ub+fa3v23cbrdpbGw0//3f/21mz55tLr/8ctPe3u7fRqz2PRIII5YsXrzYSOrxeO2114wxZy/pmjVrlrnooovMhRdeaHJzc82mTZtMV1dXwHZee+01M2vWLBMfH2+mTZtmnn/++eHvTJj66rsxxhw5csTcdNNNZuzYsSYlJcU8+OCD5pNPPgnYTiz2/Vy1tbUmPz/fuFwuk5iYaK688krz1FNPBfxxMsaY3//+9+baa681CQkJZsqUKWbNmjWWKo68H/3oR+bSSy818fHxJi8vz/z2t7+1XVLELViwwGRkZJj4+HgzZcoUs2DBAnPo0CH/8x9//LH55je/aSZMmGCSkpLM3/zN35impiaLFQ/ca6+9FvTf9uLFi40xZy/vXblypUlLSzMJCQnmhhtuMAcPHgzYxocffmgWLlxoLrroIpOcnGyWLFni/6ISzXrr+0cffWTmzZtnJk2aZMaMGWOmTp1qli5d2iN4x2rfI8FhzDnXigIAAAwz5hkBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABY9f8BRXfHYYLGKzAAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "b=np.arange(-180,180,0.01)\n",
    "b_rad=torch.Tensor(np.deg2rad(b))\n",
    "b_rad=bearing_next\n",
    "fov=np.pi/2\n",
    "a=10\n",
    "v=1/(1+torch.exp(-a*torch.cos(np.pi*b_rad/2/fov)))\n",
    "\n",
    "plt.scatter(np.rad2deg(b_rad.detach().numpy()),v.detach().numpy())"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
